1999-08-09 18:06:01 +00:00
|
|
|
/* 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).
|
|
|
|
*/
|
|
|
|
|
2003-10-09 19:34:57 +00:00
|
|
|
/*
|
|
|
|
$Log$
|
2008-03-28 14:37:36 +00:00
|
|
|
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
|
2004-10-04 18:09:05 +00:00
|
|
|
Rename global function hp_init_openfd to sanei_hp_init_openfd
|
|
|
|
|
2004-03-27 13:52:39 +00:00
|
|
|
Revision 1.13 2004/03/27 13:52:39 kig-guest
|
|
|
|
Keep USB-connection open (was problem with Linux 2.6.x)
|
|
|
|
|
2003-10-09 19:34:57 +00:00
|
|
|
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)
|
|
|
|
|
|
|
|
|
|
|
|
*/
|
|
|
|
|
2000-10-23 18:32:37 +00:00
|
|
|
/*
|
2000-03-05 13:57:25 +00:00
|
|
|
#define STUBS
|
2000-10-23 18:32:37 +00:00
|
|
|
extern int sanei_debug_hp;*/
|
|
|
|
#define DEBUG_DECLARE_ONLY
|
2000-08-12 15:11:46 +00:00
|
|
|
#include "sane/config.h"
|
2001-10-04 18:12:20 +00:00
|
|
|
#include "../include/lalloca.h" /* Must be first */
|
1999-08-09 18:06:01 +00:00
|
|
|
|
|
|
|
#ifdef HAVE_UNISTD_H
|
|
|
|
# include <unistd.h>
|
|
|
|
#endif
|
2002-12-06 19:46:39 +00:00
|
|
|
#include <stdlib.h>
|
1999-08-09 18:06:01 +00:00
|
|
|
#include <ctype.h>
|
2000-10-23 18:32:37 +00:00
|
|
|
#include <stdio.h>
|
1999-08-09 18:06:01 +00:00
|
|
|
#include <string.h>
|
|
|
|
#include <errno.h>
|
2001-10-27 18:01:54 +00:00
|
|
|
#include "../include/lassert.h"
|
1999-08-09 18:06:01 +00:00
|
|
|
#include <signal.h>
|
|
|
|
#include <sys/types.h>
|
|
|
|
#include <sys/stat.h>
|
|
|
|
#include <fcntl.h>
|
2000-08-12 15:11:46 +00:00
|
|
|
#include "sane/sanei_scsi.h"
|
2002-11-25 20:36:36 +00:00
|
|
|
#include "sane/sanei_usb.h"
|
2000-08-12 15:11:46 +00:00
|
|
|
#include "sane/sanei_pio.h"
|
1999-08-09 18:06:01 +00:00
|
|
|
|
|
|
|
#include "hp.h"
|
|
|
|
|
2000-08-12 15:11:46 +00:00
|
|
|
#include "sane/sanei_backend.h"
|
1999-08-09 18:06:01 +00:00
|
|
|
|
|
|
|
#include "hp-option.h"
|
|
|
|
#include "hp-scsi.h"
|
|
|
|
#include "hp-scl.h"
|
2001-09-04 13:51:11 +00:00
|
|
|
#include "hp-device.h"
|
1999-08-09 18:06:01 +00:00
|
|
|
|
|
|
|
#define HP_SCSI_INQ_LEN (36)
|
|
|
|
#define HP_SCSI_CMD_LEN (6)
|
|
|
|
#define HP_SCSI_BUFSIZ (HP_SCSI_MAX_WRITE + HP_SCSI_CMD_LEN)
|
|
|
|
|
2004-03-27 13:52:39 +00:00
|
|
|
#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];
|
1999-08-09 18:06:01 +00:00
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
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];
|
|
|
|
};
|
|
|
|
|
2000-03-05 13:57:25 +00:00
|
|
|
#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;
|
|
|
|
|
1999-08-09 18:06:01 +00:00
|
|
|
|
2004-03-27 13:52:39 +00:00
|
|
|
/* Initialize structure where we remember out open file descriptors */
|
|
|
|
void
|
2004-10-04 18:09:05 +00:00
|
|
|
sanei_hp_init_openfd ()
|
2004-03-27 13:52:39 +00:00
|
|
|
{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;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
1999-08-09 18:06:01 +00:00
|
|
|
static SANE_Status
|
|
|
|
hp_nonscsi_write (HpScsi this, hp_byte_t *data, size_t len, HpConnect connect)
|
|
|
|
|
2000-03-05 13:57:25 +00:00
|
|
|
{int n = -1;
|
2002-11-25 20:36:36 +00:00
|
|
|
size_t loc_len;
|
|
|
|
SANE_Status status = SANE_STATUS_GOOD;
|
1999-08-09 18:06:01 +00:00
|
|
|
|
|
|
|
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 */
|
2002-11-25 20:36:36 +00:00
|
|
|
loc_len = len;
|
|
|
|
status = sanei_usb_write_bulk ((SANE_Int)this->fd, data, &loc_len);
|
|
|
|
n = loc_len;
|
1999-08-09 18:06:01 +00:00
|
|
|
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;
|
|
|
|
|
2002-11-25 20:36:36 +00:00
|
|
|
return status;
|
1999-08-09 18:06:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static SANE_Status
|
2000-09-09 17:44:14 +00:00
|
|
|
hp_nonscsi_read (HpScsi this, hp_byte_t *data, size_t *len, HpConnect connect,
|
2002-11-25 20:36:36 +00:00
|
|
|
int UNUSEDARG isResponse)
|
1999-08-09 18:06:01 +00:00
|
|
|
|
2000-03-05 13:57:25 +00:00
|
|
|
{int n = -1;
|
2003-10-09 19:34:57 +00:00
|
|
|
static int retries = -1;
|
|
|
|
size_t save_len = *len;
|
2002-11-25 20:36:36 +00:00
|
|
|
SANE_Status status = SANE_STATUS_GOOD;
|
1999-08-09 18:06:01 +00:00
|
|
|
|
|
|
|
if (*len <= 0) return SANE_STATUS_GOOD;
|
|
|
|
|
2003-10-09 19:34:57 +00:00
|
|
|
if (retries < 0) /* Read environment */
|
|
|
|
{char *eptr = getenv ("SANE_HP_RDREDO");
|
1999-08-09 18:06:01 +00:00
|
|
|
|
2003-10-09 19:34:57 +00:00
|
|
|
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 */
|
|
|
|
}
|
|
|
|
}
|
1999-08-09 18:06:01 +00:00
|
|
|
|
2003-10-09 19:34:57 +00:00
|
|
|
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 */
|
1999-08-09 18:06:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (n == 0) return SANE_STATUS_EOF;
|
|
|
|
else if (n < 0) return SANE_STATUS_IO_ERROR;
|
|
|
|
|
|
|
|
*len = n;
|
2002-11-25 20:36:36 +00:00
|
|
|
return status;
|
1999-08-09 18:06:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static SANE_Status
|
|
|
|
hp_nonscsi_open (const char *devname, int *fd, HpConnect connect)
|
|
|
|
|
|
|
|
{int lfd, flags;
|
2002-11-25 20:36:36 +00:00
|
|
|
SANE_Int dn;
|
1999-08-09 18:06:01 +00:00
|
|
|
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:
|
2002-11-25 20:36:36 +00:00
|
|
|
DBG(17, "hp_nonscsi_open: open usb with \"%s\"\n", devname);
|
|
|
|
status = sanei_usb_open (devname, &dn);
|
|
|
|
lfd = (int)dn;
|
1999-08-09 18:06:01 +00:00
|
|
|
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);
|
|
|
|
}
|
2004-03-27 13:52:39 +00:00
|
|
|
else
|
|
|
|
{
|
|
|
|
DBG(17,"hp_nonscsi_open: device %s opened, fd=%d\n", devname, lfd);
|
|
|
|
}
|
1999-08-09 18:06:01 +00:00
|
|
|
|
|
|
|
if (fd) *fd = lfd;
|
2004-03-27 13:52:39 +00:00
|
|
|
|
1999-08-09 18:06:01 +00:00
|
|
|
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:
|
2002-11-25 20:36:36 +00:00
|
|
|
sanei_usb_close (fd);
|
1999-08-09 18:06:01 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case HP_CONNECT_RESERVE:
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
2004-03-27 13:52:39 +00:00
|
|
|
DBG(17,"hp_nonscsi_close: closed fd=%d\n", fd);
|
1999-08-09 18:06:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
SANE_Status
|
|
|
|
sanei_hp_nonscsi_new (HpScsi * newp, const char * devname, HpConnect connect)
|
|
|
|
{
|
|
|
|
HpScsi new;
|
|
|
|
SANE_Status status;
|
2004-03-27 13:52:39 +00:00
|
|
|
int iAlreadyOpen = 0;
|
1999-08-09 18:06:01 +00:00
|
|
|
|
|
|
|
new = sanei_hp_allocz(sizeof(*new));
|
|
|
|
if (!new)
|
|
|
|
return SANE_STATUS_NO_MEM;
|
|
|
|
|
2004-03-27 13:52:39 +00:00
|
|
|
/* Is the device already open ? */
|
|
|
|
if ( hp_GetOpenDevice (devname, connect, &new->fd) == SANE_STATUS_GOOD )
|
|
|
|
{
|
|
|
|
iAlreadyOpen = 1;
|
|
|
|
}
|
|
|
|
else
|
1999-08-09 18:06:01 +00:00
|
|
|
{
|
2004-03-27 13:52:39 +00:00
|
|
|
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;
|
|
|
|
}
|
1999-08-09 18:06:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* For SCSI-devices we would have the inquire command here */
|
2002-11-25 20:36:36 +00:00
|
|
|
strncpy ((char *)new->inq_data, "\003zzzzzzzHP ------ R000",
|
1999-08-09 18:06:01 +00:00
|
|
|
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;
|
2004-03-27 13:52:39 +00:00
|
|
|
|
|
|
|
/* Remember the open device */
|
|
|
|
if (!iAlreadyOpen) hp_AddOpenDevice (devname, connect, new->fd);
|
|
|
|
|
1999-08-09 18:06:01 +00:00
|
|
|
return SANE_STATUS_GOOD;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2004-03-27 13:52:39 +00:00
|
|
|
hp_scsi_close (HpScsi this, int completely)
|
1999-08-09 18:06:01 +00:00
|
|
|
{HpConnect connect;
|
|
|
|
|
2000-09-09 17:44:14 +00:00
|
|
|
DBG(3, "scsi_close: closing fd %ld\n", (long)this->fd);
|
|
|
|
|
1999-08-09 18:06:01 +00:00
|
|
|
connect = sanei_hp_scsi_get_connect (this);
|
|
|
|
|
2004-03-27 13:52:39 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
2000-09-09 17:44:14 +00:00
|
|
|
assert(this->fd >= 0);
|
|
|
|
|
1999-08-09 18:06:01 +00:00
|
|
|
if (connect != HP_CONNECT_SCSI)
|
|
|
|
hp_nonscsi_close (this->fd, connect);
|
|
|
|
else
|
|
|
|
sanei_scsi_close (this->fd);
|
2004-03-27 13:52:39 +00:00
|
|
|
|
|
|
|
DBG(3,"scsi_close: really closed\n");
|
|
|
|
|
|
|
|
/* Remove a remembered open device */
|
|
|
|
hp_RemoveOpenFd (this->fd, connect);
|
1999-08-09 18:06:01 +00:00
|
|
|
}
|
|
|
|
|
2004-03-27 13:52:39 +00:00
|
|
|
|
1999-08-09 18:06:01 +00:00
|
|
|
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;
|
2004-03-27 13:52:39 +00:00
|
|
|
int iAlreadyOpen = 0;
|
1999-08-09 18:06:01 +00:00
|
|
|
|
|
|
|
connect = sanei_hp_get_connect (devname);
|
2004-03-27 13:52:39 +00:00
|
|
|
|
1999-08-09 18:06:01 +00:00
|
|
|
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;
|
|
|
|
|
2004-03-27 13:52:39 +00:00
|
|
|
/* 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;
|
|
|
|
}
|
|
|
|
}
|
1999-08-09 18:06:01 +00:00
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2002-12-06 19:46:39 +00:00
|
|
|
{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);
|
|
|
|
}
|
|
|
|
|
1999-08-09 18:06:01 +00:00
|
|
|
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));
|
2003-10-09 19:34:57 +00:00
|
|
|
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));
|
|
|
|
|
1999-08-09 18:06:01 +00:00
|
|
|
sanei_scsi_close(new->fd);
|
|
|
|
sanei_hp_free(new);
|
2000-03-05 13:57:25 +00:00
|
|
|
return status; /* Fix problem with non-scanner devices */
|
1999-08-09 18:06:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
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;
|
2004-03-27 13:52:39 +00:00
|
|
|
|
|
|
|
/* Remember the open device */
|
|
|
|
if (!iAlreadyOpen) hp_AddOpenDevice (devname, connect, new->fd);
|
|
|
|
|
1999-08-09 18:06:01 +00:00
|
|
|
return SANE_STATUS_GOOD;
|
|
|
|
}
|
|
|
|
|
2000-09-09 17:44:14 +00:00
|
|
|
|
|
|
|
|
|
|
|
/* 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. */
|
1999-08-09 18:06:01 +00:00
|
|
|
void
|
2004-03-27 13:52:39 +00:00
|
|
|
sanei_hp_scsi_destroy (HpScsi this,int completely)
|
1999-08-09 18:06:01 +00:00
|
|
|
{
|
2000-09-09 17:44:14 +00:00
|
|
|
/* Moved to hp_scsi_close():
|
|
|
|
* assert(this->fd >= 0);
|
|
|
|
* DBG(3, "scsi_close: closing fd %d\n", this->fd);
|
|
|
|
*/
|
1999-08-09 18:06:01 +00:00
|
|
|
|
2004-03-27 13:52:39 +00:00
|
|
|
hp_scsi_close (this, completely);
|
1999-08-09 18:06:01 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2001-09-04 13:51:11 +00:00
|
|
|
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;
|
|
|
|
|
2002-11-25 20:36:36 +00:00
|
|
|
if ( sanei_hp_device_probe_model ( &compat, scsi, &model_num, 0)
|
2001-09-04 13:51:11 +00:00
|
|
|
== 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));
|
|
|
|
}
|
|
|
|
|
|
|
|
|
1999-08-09 18:06:01 +00:00
|
|
|
HpConnect
|
|
|
|
sanei_hp_get_connect (const char *devname)
|
|
|
|
|
|
|
|
{const HpDeviceInfo *info;
|
2002-08-06 19:33:08 +00:00
|
|
|
HpConnect connect = HP_CONNECT_SCSI;
|
|
|
|
int got_connect_type = 0;
|
1999-08-09 18:06:01 +00:00
|
|
|
|
|
|
|
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);
|
2002-08-06 19:33:08 +00:00
|
|
|
connect = HP_CONNECT_SCSI;
|
1999-08-09 18:06:01 +00:00
|
|
|
}
|
2002-08-06 19:33:08 +00:00
|
|
|
else
|
1999-08-09 18:06:01 +00:00
|
|
|
if ( !(info->config_is_up) )
|
|
|
|
{
|
|
|
|
DBG(1, "sanei_hp_get_connect: Config not initialized for %s. Assume SCSI\n",
|
|
|
|
devname);
|
2002-08-06 19:33:08 +00:00
|
|
|
connect = HP_CONNECT_SCSI;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
connect = info->config.connect;
|
|
|
|
got_connect_type = info->config.got_connect_type;
|
1999-08-09 18:06:01 +00:00
|
|
|
}
|
|
|
|
|
2002-08-06 19:33:08 +00:00
|
|
|
/* 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;
|
1999-08-09 18:06:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
2000-03-05 13:57:25 +00:00
|
|
|
DBG(16, "scsi_flush: writing %lu bytes:\n", (unsigned long) len);
|
|
|
|
DBGDUMP(16, data, len);
|
1999-08-09 18:06:01 +00:00
|
|
|
|
|
|
|
*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);
|
|
|
|
}
|
|
|
|
|
2000-08-12 15:11:46 +00:00
|
|
|
static size_t
|
1999-08-09 18:06:01 +00:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2002-12-06 19:46:39 +00:00
|
|
|
/* 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;
|
|
|
|
}
|
1999-08-09 18:06:01 +00:00
|
|
|
|
2000-09-09 17:44:14 +00:00
|
|
|
/* The OfficeJets tend to return inquiry responses containing array
|
|
|
|
* data in two packets. The added "isResponse" parameter tells
|
2002-11-25 20:36:36 +00:00
|
|
|
* whether we should keep reading until we get
|
2000-09-09 17:44:14 +00:00
|
|
|
* a well-formed response. Naturally, this parameter would be zero
|
|
|
|
* when reading scan data. */
|
1999-08-09 18:06:01 +00:00
|
|
|
static SANE_Status
|
2000-09-09 17:44:14 +00:00
|
|
|
hp_scsi_read (HpScsi this, void * dest, size_t *len, int isResponse)
|
1999-08-09 18:06:01 +00:00
|
|
|
{
|
|
|
|
HpConnect connect;
|
|
|
|
|
|
|
|
RETURN_IF_FAIL( hp_scsi_flush(this) );
|
|
|
|
|
|
|
|
connect = sanei_hp_scsi_get_connect (this);
|
|
|
|
if (connect == HP_CONNECT_SCSI)
|
2002-12-06 19:46:39 +00:00
|
|
|
{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));
|
|
|
|
}
|
1999-08-09 18:06:01 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2000-09-09 17:44:14 +00:00
|
|
|
RETURN_IF_FAIL( hp_nonscsi_read (this, dest, len, connect, isResponse) );
|
1999-08-09 18:06:01 +00:00
|
|
|
}
|
2000-03-05 13:57:25 +00:00
|
|
|
DBG(16, "scsi_read: %lu bytes:\n", (unsigned long) *len);
|
|
|
|
DBGDUMP(16, dest, *len);
|
1999-08-09 18:06:01 +00:00
|
|
|
return SANE_STATUS_GOOD;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static int signal_caught = 0;
|
|
|
|
|
|
|
|
static RETSIGTYPE
|
|
|
|
signal_catcher (int sig)
|
|
|
|
{
|
2000-09-09 17:44:14 +00:00
|
|
|
DBG(1,"signal_catcher(sig=%d): old signal_caught=%d\n",sig,signal_caught);
|
1999-08-09 18:06:01 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2000-03-05 13:57:25 +00:00
|
|
|
|
|
|
|
/* 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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2000-09-09 17:44:14 +00:00
|
|
|
|
|
|
|
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--;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2000-03-05 13:57:25 +00:00
|
|
|
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;
|
2000-09-09 17:44:14 +00:00
|
|
|
if (procdata->out8) tsz /= 2;
|
2000-03-05 13:57:25 +00:00
|
|
|
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);
|
2000-09-09 17:44:14 +00:00
|
|
|
/* 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))
|
2000-03-05 13:57:25 +00:00
|
|
|
{
|
|
|
|
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 )
|
|
|
|
{
|
2000-09-09 17:44:14 +00:00
|
|
|
if ( signal_caught
|
|
|
|
|| (write (ph->outfd, data, ph->wr_buf_size) != ph->wr_buf_size))
|
2000-03-05 13:57:25 +00:00
|
|
|
{
|
|
|
|
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)
|
|
|
|
|
2000-09-09 17:44:14 +00:00
|
|
|
{int out_bytes_per_line = bytes_per_line;
|
2000-03-05 13:57:25 +00:00
|
|
|
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)
|
2000-09-09 17:44:14 +00:00
|
|
|
{
|
|
|
|
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);
|
|
|
|
}
|
2000-03-05 13:57:25 +00:00
|
|
|
|
|
|
|
if ( ph->image_buf )
|
|
|
|
{
|
|
|
|
DBG(5, "process_scanline: save in memory\n");
|
|
|
|
|
2000-09-09 17:44:14 +00:00
|
|
|
if ( ph->image_ptr+out_bytes_per_line-1
|
|
|
|
<= ph->image_buf+ph->image_buf_size-1 )
|
2000-03-05 13:57:25 +00:00
|
|
|
{
|
2000-09-09 17:44:14 +00:00
|
|
|
memcpy(ph->image_ptr, linebuf, out_bytes_per_line);
|
|
|
|
ph->image_ptr += out_bytes_per_line;
|
2000-03-05 13:57:25 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
DBG(1, "process_scanline: would exceed image buffer\n");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else /* Save scanlines in a bigger buffer. */
|
|
|
|
{ /* Otherwise we will get performance problems */
|
|
|
|
|
2000-09-09 17:44:14 +00:00
|
|
|
RETURN_IF_FAIL ( process_data_write (ph, linebuf, out_bytes_per_line) );
|
2000-03-05 13:57:25 +00:00
|
|
|
}
|
|
|
|
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;
|
2000-09-09 17:44:14 +00:00
|
|
|
if ( signal_caught || (write (ph->outfd, ph->wr_buf, nbytes) != nbytes))
|
2000-03-05 13:57:25 +00:00
|
|
|
{
|
|
|
|
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;
|
2000-09-09 17:44:14 +00:00
|
|
|
if (procdata->out8) bytes_per_line /= 2;
|
2000-03-05 13:57:25 +00:00
|
|
|
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 )
|
|
|
|
{
|
2000-09-09 17:44:14 +00:00
|
|
|
if ( signal_caught
|
|
|
|
|| (write(ph->outfd, image_data, bytes_per_line) != bytes_per_line))
|
2000-03-05 13:57:25 +00:00
|
|
|
{
|
|
|
|
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 )
|
|
|
|
{
|
2000-09-09 17:44:14 +00:00
|
|
|
if ( signal_caught
|
|
|
|
|| (write(ph->outfd, image_data, bytes_per_line) != bytes_per_line))
|
2000-03-05 13:57:25 +00:00
|
|
|
{
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
1999-08-09 18:06:01 +00:00
|
|
|
SANE_Status
|
2000-03-05 13:57:25 +00:00
|
|
|
sanei_hp_scsi_pipeout (HpScsi this, int outfd, HpProcessData *procdata)
|
1999-08-09 18:06:01 +00:00
|
|
|
{
|
|
|
|
/* 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;
|
2000-03-05 13:57:25 +00:00
|
|
|
int bits_per_channel = procdata->bits_per_channel;
|
1999-08-09 18:06:01 +00:00
|
|
|
|
|
|
|
#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];
|
2000-03-05 13:57:25 +00:00
|
|
|
} buf[2], *req = NULL;
|
2002-08-06 19:33:08 +00:00
|
|
|
|
1999-08-09 18:06:01 +00:00
|
|
|
int reqs_completed = 0;
|
|
|
|
int reqs_issued = 0;
|
2000-03-05 13:57:25 +00:00
|
|
|
char *image_buf = 0;
|
1999-08-09 18:06:01 +00:00
|
|
|
char *read_buf = 0;
|
|
|
|
const HpDeviceInfo *info;
|
|
|
|
const char *devname = sanei_hp_scsi_devicename (this);
|
2002-08-06 19:33:08 +00:00
|
|
|
int enable_requests = 1;
|
|
|
|
int enable_image_buffering = 0;
|
1999-08-09 18:06:01 +00:00
|
|
|
const unsigned char *map = NULL;
|
2002-08-06 19:33:08 +00:00
|
|
|
HpConnect connect;
|
2000-03-05 13:57:25 +00:00
|
|
|
PROCDATA_HANDLE *ph = NULL;
|
|
|
|
size_t count = procdata->lines * procdata->bytes_per_line;
|
1999-08-09 18:06:01 +00:00
|
|
|
|
|
|
|
RETURN_IF_FAIL( hp_scsi_flush(this) );
|
|
|
|
|
2002-08-06 19:33:08 +00:00
|
|
|
connect = sanei_hp_get_connect (devname);
|
1999-08-09 18:06:01 +00:00
|
|
|
info = sanei_hp_device_info_get (devname);
|
|
|
|
|
|
|
|
assert (info);
|
|
|
|
|
|
|
|
if ( info->config_is_up )
|
|
|
|
{
|
|
|
|
enable_requests = info->config.use_scsi_request;
|
2000-03-05 13:57:25 +00:00
|
|
|
enable_image_buffering = info->config.use_image_buffering;
|
1999-08-09 18:06:01 +00:00
|
|
|
}
|
|
|
|
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);
|
2000-03-05 13:57:25 +00:00
|
|
|
for (i = 0; i < (int)(HP_NSIGS); i++)
|
1999-08-09 18:06:01 +00:00
|
|
|
{
|
|
|
|
sigaction(kill_sig[i], &sa, &old_handler[i]);
|
|
|
|
sigaddset(&sig_set, kill_sig[i]);
|
|
|
|
}
|
|
|
|
signal_caught = 0;
|
|
|
|
sigprocmask(SIG_UNBLOCK, &sig_set, 0);
|
|
|
|
|
2000-08-12 15:11:46 +00:00
|
|
|
/* Wait for front button push ? */
|
|
|
|
if ( procdata->startscan )
|
|
|
|
{
|
|
|
|
for (;;)
|
|
|
|
{int val = 0;
|
2002-08-06 19:33:08 +00:00
|
|
|
|
2000-08-12 15:11:46 +00:00
|
|
|
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;
|
|
|
|
}
|
2002-08-06 19:33:08 +00:00
|
|
|
}
|
2000-03-05 13:57:25 +00:00
|
|
|
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;
|
|
|
|
}
|
1999-08-09 18:06:01 +00:00
|
|
|
|
|
|
|
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;
|
|
|
|
|
2000-03-05 13:57:25 +00:00
|
|
|
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;
|
|
|
|
}
|
1999-08-09 18:06:01 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
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);
|
|
|
|
|
2000-09-09 17:44:14 +00:00
|
|
|
status = hp_scsi_read (this, read_buf, &nread, 0);
|
1999-08-09 18:06:01 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2000-03-05 13:57:25 +00:00
|
|
|
status = process_data (ph, (unsigned char *)read_buf, (int)nread);
|
|
|
|
if ( status != SANE_STATUS_GOOD )
|
1999-08-09 18:06:01 +00:00
|
|
|
{
|
2000-03-05 13:57:25 +00:00
|
|
|
DBG(1,"do_read: Error in process_data\n");
|
|
|
|
goto quit;
|
1999-08-09 18:06:01 +00:00
|
|
|
}
|
|
|
|
count -= nread;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2000-03-05 13:57:25 +00:00
|
|
|
process_data_flush (ph);
|
1999-08-09 18:06:01 +00:00
|
|
|
|
|
|
|
quit:
|
|
|
|
|
2000-03-05 13:57:25 +00:00
|
|
|
process_data_finish (ph);
|
|
|
|
|
1999-08-09 18:06:01 +00:00
|
|
|
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);
|
2000-03-05 13:57:25 +00:00
|
|
|
for (i = 0; i < (int)(HP_NSIGS); i++)
|
1999-08-09 18:06:01 +00:00
|
|
|
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)) );
|
2008-03-28 14:37:36 +00:00
|
|
|
usleep (1000); /* 500 works, too, but not 100 */
|
1999-08-09 18:06:01 +00:00
|
|
|
|
2000-09-09 17:44:14 +00:00
|
|
|
status = hp_scsi_read(scsi, buf, &bufsize, 1);
|
1999-08-09 18:06:01 +00:00
|
|
|
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 */
|
2000-08-12 15:11:46 +00:00
|
|
|
DBG(3, "scl_inq: parameter %d unsupported\n", SCL_INQ_ID(scl));
|
1999-08-09 18:06:01 +00:00
|
|
|
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
|
|
|
|
{
|
2000-03-05 13:57:25 +00:00
|
|
|
if (val > (int)*lengthp)
|
1999-08-09 18:06:01 +00:00
|
|
|
{
|
|
|
|
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)) );
|
|
|
|
|
2000-09-09 17:44:14 +00:00
|
|
|
status = hp_scsi_read(scsi, buf, &bufsize, 0);
|
1999-08-09 18:06:01 +00:00
|
|
|
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 */
|
2000-08-12 15:11:46 +00:00
|
|
|
DBG(1, "scl_upload_binary: parameter %d unsupported\n", SCL_INQ_ID(scl));
|
1999-08-09 18:06:01 +00:00
|
|
|
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;
|
2000-09-09 17:44:14 +00:00
|
|
|
status = hp_scsi_read(scsi, hpdata, &sv, 0);
|
1999-08-09 18:06:01 +00:00
|
|
|
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
|
2000-03-05 13:57:25 +00:00
|
|
|
sanei_hp_scl_startScan(HpScsi scsi, HpScl scl)
|
1999-08-09 18:06:01 +00:00
|
|
|
{
|
2000-03-05 13:57:25 +00:00
|
|
|
char *msg = "";
|
1999-08-09 18:06:01 +00:00
|
|
|
|
2000-03-05 13:57:25 +00:00
|
|
|
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);
|
|
|
|
|
2001-09-04 13:51:11 +00:00
|
|
|
/* 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;
|
|
|
|
}
|
|
|
|
|
2000-03-05 13:57:25 +00:00
|
|
|
RETURN_IF_FAIL( hp_scsi_scl(scsi, scl, 0) );
|
1999-08-09 18:06:01 +00:00
|
|
|
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"
|
|
|
|
};
|
|
|
|
|
2000-03-05 13:57:25 +00:00
|
|
|
if (errnum >= 0 && errnum < (int)(sizeof(errlist)/sizeof(errlist[0])))
|
1999-08-09 18:06:01 +00:00
|
|
|
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;
|
|
|
|
}
|