static SANE_Status
usb_send_command (struct scanner *s, struct cmd *c, struct response *r,
void *buf)
{
SANE_Status st;
struct bulk_header *h = (struct bulk_header *) buf;
u8 resp[sizeof (*h) + STATUS_SIZE];
size_t sz = sizeof (*h) + MAX_CMD_SIZE;
memset (h, 0, sz);
h->length = cpu2be32 (sz);
h->type = cpu2be16 (COMMAND_BLOCK);
h->code = cpu2be16 (COMMAND_CODE);
memcpy (h + 1, c->cmd, c->cmd_size);
st = sanei_usb_write_bulk (s->file, (const SANE_Byte *) h, &sz);
if (st)
return st;
if (sz != sizeof (*h) + MAX_CMD_SIZE)
return SANE_STATUS_IO_ERROR;
if (c->dir == CMD_IN)
{
sz = sizeof (*h) + c->data_size;
st = sanei_usb_read_bulk (s->file, (SANE_Byte *) h, &sz);
c->data = h + 1;
c->data_size = sz - sizeof (*h);
if (st || sz < sizeof (*h))
{
st = sanei_usb_release_interface (s->file, 0);
if (st)
return st;
st = sanei_usb_claim_interface (s->file, 0);
if (st)
return st;
r->status = CHECK_CONDITION;
return SANE_STATUS_GOOD;
}
}
else if (c->dir == CMD_OUT)
{
sz = sizeof (*h) + c->data_size;
memset (h, 0, sizeof (*h));
h->length = cpu2be32 (sizeof (*h) + c->data_size);
h->type = cpu2be16 (DATA_BLOCK);
h->code = cpu2be16 (DATA_CODE);
memcpy (h + 1, c->data, c->data_size);
st = sanei_usb_write_bulk (s->file, (const SANE_Byte *) h, &sz);
if (st)
return st;
}
sz = sizeof (resp);
st = sanei_usb_read_bulk (s->file, resp, &sz);
if (st || sz != sizeof (resp))
return SANE_STATUS_IO_ERROR;
r->status = be2cpu32 (*((u32 *) (resp + sizeof (*h))));
return st;
}
SANE_Status
sane_start (SANE_Handle h)
{
struct device_s *dev = (struct device_s *) h;
int status;
size_t size;
dev->read_offset = 0;
dev->write_offset_r = 0;
dev->write_offset_g = 1;
dev->write_offset_b = 2;
free (dev->buffer);
dev->buffer = NULL;
send_pkt (PKT_RESET, 0, dev);
send_pkt (PKT_READ_STATUS, 0, dev);
wait_ack (dev, &status);
if (status)
return SANE_STATUS_IO_ERROR;
send_pkt (PKT_READCONF, 0, dev);
if ((size = wait_ack (dev, NULL)))
{
sanei_usb_read_bulk (dev->dn, (unsigned char *) dev->conf_data, &size);
}
send_pkt (PKT_SETCONF, 100, dev);
send_conf (dev);
wait_ack (dev, NULL);
send_pkt (PKT_START_SCAN, 0, dev);
wait_ack (dev, NULL);
if ((size = wait_ack (dev, NULL)))
{
sanei_usb_read_bulk (dev->dn, (unsigned char *) dev->conf_data, &size);
}
if ((size = wait_ack (dev, NULL)))
{
sanei_usb_read_bulk (dev->dn, (unsigned char *) dev->conf_data, &size);
}
if ((size = wait_ack (dev, NULL)))
{
sanei_usb_read_bulk (dev->dn, (unsigned char *) dev->conf_data, &size);
}
dev->status = STATUS_SCANNING;
/* Get the first data */
return get_data (dev);
}
/**
* read available data count from scanner
* from tests it appears that advertised data
* may not be really available, and that a pause must be made
* before reading data so that it is really there.
* Such as reading data twice.
*/
SANE_Status
sanei_rts88xx_data_count (SANE_Int devnum, SANE_Word * count)
{
SANE_Status status;
size_t size;
static SANE_Byte header[4] = { 0x90, 0x00, 0x00, 3 };
SANE_Byte result[3];
/* set count in case of failure */
*count = 0;
size = 4;
status = sanei_usb_write_bulk (devnum, header, &size);
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error, "sanei_rts88xx_data_count : failed to write header\n");
return status;
}
size = 3;
status = sanei_usb_read_bulk (devnum, result, &size);
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error,
"sanei_rts88xx_data_count : failed to read data count\n");
return status;
}
*count = result[0] + (result[1] << 8) + (result[2] << 16);
DBG (DBG_io2, "sanei_rts88xx_data_count: %d bytes available (0x%06x)\n",
*count, *count);
return status;
}
/*
* read one register at given index
*/
SANE_Status
sanei_rts88xx_read_reg (SANE_Int devnum, SANE_Int index, SANE_Byte * reg)
{
SANE_Status status = SANE_STATUS_GOOD;
unsigned char cmd[] = { 0x80, 0x00, 0x00, 0x01 };
size_t size;
cmd[1] = index;
size = 4;
status = sanei_usb_write_bulk (devnum, cmd, &size);
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error, "sanei_rts88xx_read_reg: bulk write failed\n");
return status;
}
size = 1;
status = sanei_usb_read_bulk (devnum, reg, &size);
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error, "sanei_rts88xx_read_reg: bulk read failed\n");
return status;
}
DBG (DBG_io2, "sanei_rts88xx_read_reg: reg[0x%02x]=0x%02x\n", index, *reg);
return status;
}
int
usb_dev_request (struct device *dev,
SANE_Byte *cmd, size_t cmdlen,
SANE_Byte *resp, size_t *resplen)
{
SANE_Status status;
size_t len = cmdlen;
if (cmd && cmdlen) {
status = sanei_usb_write_bulk (dev->dn, cmd, &cmdlen);
if (status != SANE_STATUS_GOOD) {
DBG (1, "%s: sanei_usb_write_bulk: %s\n", __FUNCTION__,
sane_strstatus (status));
return SANE_STATUS_IO_ERROR;
}
if (cmdlen != len) {
DBG (1, "%s: sanei_usb_write_bulk: wanted %lu bytes, wrote %lu bytes\n",
__FUNCTION__, (size_t)len, (size_t)cmdlen);
return SANE_STATUS_IO_ERROR;
}
}
if (resp && resplen) {
status = sanei_usb_read_bulk (dev->dn, resp, resplen);
if (status != SANE_STATUS_GOOD) {
DBG (1, "%s: sanei_usb_read_bulk: %s\n", __FUNCTION__,
sane_strstatus (status));
return SANE_STATUS_IO_ERROR;
}
}
return SANE_STATUS_GOOD;
}
/* read several registers starting at the given index */
SANE_Status
sanei_rts88xx_read_regs (SANE_Int devnum, SANE_Int start,
SANE_Byte * dest, SANE_Int length)
{
SANE_Status status;
static SANE_Byte command_block[] = { 0x80, 0, 0x00, 0xFF };
size_t size, i;
char message[256 * 5];
if (start + length > 255)
{
DBG (DBG_error,
"sanei_rts88xx_read_regs: start and length must be within [0..255]\n");
return SANE_STATUS_INVAL;
}
/* write header */
size = 4;
command_block[1] = start;
command_block[3] = length;
status = sanei_usb_write_bulk (devnum, command_block, &size);
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error, "sanei_rts88xx_read_regs: failed to write header\n");
return status;
}
/* read data */
size = length;
status = sanei_usb_read_bulk (devnum, dest, &size);
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error, "sanei_rts88xx_read_regs: failed to read data\n");
return status;
}
if (size != (size_t) length)
{
DBG (DBG_warn, "sanei_rts88xx_read_regs: read got only %lu bytes\n",
(u_long) size);
}
if (DBG_LEVEL >= DBG_io)
{
for (i = 0; i < size; i++)
sprintf (message + 5 * i, "0x%02x ", dest[i]);
DBG (DBG_io, "sanei_rts88xx_read_regs: read_regs(0x%02x,%d)=%s\n",
start, length, message);
}
return status;
}
/* Return the next packet size */
static int
wait_ack (struct device_s *dev, int *s)
{
SANE_Status ret;
size_t size;
DBG(100, "Waiting scanner answer on device %s\n",dev->devname);
do
{
size = 32;
ret =
sanei_usb_read_bulk (dev->dn, (unsigned char *) dev->packet_data,
&size);
}
while (SANE_STATUS_EOF == ret || size == 0);
if (s)
*s = ntohl (dev->packet_data[4]);
return ntohl (dev->packet_data[5]);
}
/*
* read length bytes of memory into area pointed by value
*/
SANE_Status
sanei_rts88xx_read_mem (SANE_Int devnum, SANE_Int length, SANE_Byte * value)
{
SANE_Status status;
size_t size, read, want;
SANE_Byte header[4];
/* build and write length header */
header[0] = 0x81;
header[1] = 0x00;
header[2] = HIBYTE (length);
header[3] = LOBYTE (length);
size = 4;
status = sanei_usb_write_bulk (devnum, header, &size);
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error,
"sanei_rts88xx_read_mem: failed to write length header\n");
return status;
}
DBG (DBG_io, "sanei_rts88xx_read_mem: %02x %02x %02x %02x -> ...\n",
header[0], header[1], header[2], header[3]);
read = 0;
while (length > 0)
{
if (length > 2048)
want = 2048;
else
want = length;
size = want;
status = sanei_usb_read_bulk (devnum, value + read, &size);
if (size != want)
{
DBG (DBG_error,
"sanei_rts88xx_read_mem: only read %lu bytes out of %lu\n",
(u_long) size, (u_long) want);
status = SANE_STATUS_IO_ERROR;
}
length -= size;
read += size;
}
return status;
}
static ssize_t
channel_usb_recv (channel *self, void *buffer,
size_t size, SANE_Status *status)
{
ssize_t n = size;
if (self->interpreter)
{
n = self->interpreter->recv (self, buffer, size, status);
}
else
{
SANE_Status s = SANE_STATUS_GOOD;
s = sanei_usb_read_bulk (self->fd, (SANE_Byte *) buffer, (size_t *)&n);
if (status) *status = s;
}
return n;
}
/*
* take a bunch of pointers, send commands to scanner
*/
static SANE_Status
do_cmd(struct scanner *s, int shortTime,
unsigned char * cmdBuff, size_t cmdLen,
unsigned char * outBuff, size_t outLen,
unsigned char * inBuff, size_t * inLen
)
{
/* sanei_usb overwrites the transfer size, so make some local copies */
size_t loc_cmdLen = cmdLen;
size_t loc_outLen = outLen;
size_t loc_inLen = *inLen;
int cmdTime = USB_COMMAND_TIME;
int outTime = USB_DATA_TIME;
int inTime = USB_DATA_TIME;
int ret = 0;
DBG (10, "do_cmd: start\n");
if(shortTime){
cmdTime /= 20;
outTime /= 20;
inTime /= 20;
}
/* change timeout */
sanei_usb_set_timeout(cmdTime);
/* write the command out */
DBG(25, "cmd: writing %ld bytes, timeout %d\n", (long)cmdLen, cmdTime);
hexdump(30, "cmd: >>", cmdBuff, cmdLen);
ret = sanei_usb_write_bulk(s->fd, cmdBuff, &cmdLen);
DBG(25, "cmd: wrote %ld bytes, retVal %d\n", (long)cmdLen, ret);
if(ret == SANE_STATUS_EOF){
DBG(5,"cmd: got EOF, returning IO_ERROR\n");
return SANE_STATUS_IO_ERROR;
}
if(ret != SANE_STATUS_GOOD){
DBG(5,"cmd: return error '%s'\n",sane_strstatus(ret));
return ret;
}
if(loc_cmdLen != cmdLen){
DBG(5,"cmd: wrong size %ld/%ld\n", (long)loc_cmdLen, (long)cmdLen);
return SANE_STATUS_IO_ERROR;
}
/* this command has a write component, and a place to get it */
if(outBuff && outLen && outTime){
/* change timeout */
sanei_usb_set_timeout(outTime);
DBG(25, "out: writing %ld bytes, timeout %d\n", (long)outLen, outTime);
hexdump(30, "out: >>", outBuff, outLen);
ret = sanei_usb_write_bulk(s->fd, outBuff, &outLen);
DBG(25, "out: wrote %ld bytes, retVal %d\n", (long)outLen, ret);
if(ret == SANE_STATUS_EOF){
DBG(5,"out: got EOF, returning IO_ERROR\n");
return SANE_STATUS_IO_ERROR;
}
if(ret != SANE_STATUS_GOOD){
DBG(5,"out: return error '%s'\n",sane_strstatus(ret));
return ret;
}
if(loc_outLen != outLen){
DBG(5,"out: wrong size %ld/%ld\n", (long)loc_outLen, (long)outLen);
return SANE_STATUS_IO_ERROR;
}
}
/* this command has a read component, and a place to put it */
if(inBuff && inLen && inTime){
memset(inBuff,0,*inLen);
/* change timeout */
sanei_usb_set_timeout(inTime);
DBG(25, "in: reading %ld bytes, timeout %d\n", (long)*inLen, inTime);
ret = sanei_usb_read_bulk(s->fd, inBuff, inLen);
DBG(25, "in: retVal %d\n", ret);
if(ret == SANE_STATUS_EOF){
DBG(5,"in: got EOF, continuing\n");
}
else if(ret != SANE_STATUS_GOOD){
DBG(5,"in: return error '%s'\n",sane_strstatus(ret));
return ret;
}
DBG(25, "in: read %ld bytes\n", (long)*inLen);
if(*inLen){
hexdump(30, "in: <<", inBuff, *inLen);
}
if(loc_inLen != *inLen){
ret = SANE_STATUS_EOF;
DBG(5,"in: short read %ld/%ld\n", (long)loc_inLen, (long)*inLen);
}
}
DBG (10, "do_cmd: finish\n");
return ret;
}
static SANE_Status
get_data (struct device_s *dev)
{
int color;
size_t size;
int packet_size;
unsigned char *buffer = (unsigned char *) dev->packet_data;
if (dev->status == STATUS_IDLE)
return SANE_STATUS_IO_ERROR;
/* first wait a standard data pkt */
do
{
size = 32;
sanei_usb_read_bulk (dev->dn, buffer, &size);
if (size)
{
if (ntohl (dev->packet_data[0]) == MAGIC_NUMBER)
{
if (ntohl (dev->packet_data[1]) == PKT_DATA)
break;
if (ntohl (dev->packet_data[1]) == PKT_END_DATA)
{
dev->status = STATUS_IDLE;
DBG(100,"End of scan encountered on device %s\n",dev->devname);
send_pkt (PKT_GO_IDLE, 0, dev);
wait_ack (dev, NULL);
wait_ack (dev, NULL);
send_pkt (PKT_UNKNOW_1, 0, dev);
wait_ack (dev, NULL);
send_pkt (PKT_RESET, 0, dev);
sleep (2); /* Time for the scanning head to go back home */
return SANE_STATUS_EOF;
}
}
}
}
while (1);
packet_size = ntohl (dev->packet_data[5]);
if (!dev->buffer)
{
dev->bufs = packet_size - 24 /* size of header */ ;
if (dev->optionw[COLOR_OFFSET] == RGB)
dev->bufs *= 3;
dev->buffer = malloc (dev->bufs);
if (!dev->buffer)
return SANE_STATUS_NO_MEM;
dev->write_offset_r = 0;
dev->write_offset_g = 1;
dev->write_offset_b = 2;
}
/* Get the "data header" */
do
{
size = 24;
sanei_usb_read_bulk (dev->dn, buffer, &size);
}
while (!size);
color = ntohl (dev->packet_data[0]);
packet_size -= size;
dev->width = ntohl (dev->packet_data[5]);
DBG(100,"Got data size %d on device %s. Scan width: %d\n",packet_size, dev->devname, dev->width);
/* Now, read the data */
do
{
int j;
int i;
int ret;
do
{
size = packet_size > 512 ? 512 : packet_size;
ret = sanei_usb_read_bulk (dev->dn, buffer, &size);
}
while (!size || ret != SANE_STATUS_GOOD);
packet_size -= size;
switch (color)
{
case RED_LAYER:
DBG(101,"Got red layer data on device %s\n",dev->devname);
i = dev->write_offset_r + 3 * size;
if (i > dev->bufs)
i = dev->bufs;
for (j = 0; dev->write_offset_r < i; dev->write_offset_r += 3)
dev->buffer[dev->write_offset_r] = buffer[j++];
break;
case GREEN_LAYER:
DBG(101,"Got green layer data on device %s\n",dev->devname);
i = dev->write_offset_g + 3 * size;
if (i > dev->bufs)
i = dev->bufs;
for (j = 0; dev->write_offset_g < i; dev->write_offset_g += 3)
dev->buffer[dev->write_offset_g] = buffer[j++];
break;
case BLUE_LAYER:
DBG(101,"Got blue layer data on device %s\n",dev->devname);
i = dev->write_offset_b + 3 * size;
if (i > dev->bufs)
i = dev->bufs;
for (j = 0; dev->write_offset_b < i; dev->write_offset_b += 3)
dev->buffer[dev->write_offset_b] = buffer[j++];
break;
case GRAY_LAYER:
DBG(101,"Got gray layer data on device %s\n",dev->devname);
if (dev->write_offset_r + (int)size >= dev->bufs)
size = dev->bufs - dev->write_offset_r;
memcpy (dev->buffer + dev->write_offset_r, buffer, size);
dev->write_offset_r += size;
break;
}
}
while (packet_size > 0);
return SANE_STATUS_GOOD;
}
/*
* read scanned data from scanner up to the size given. The actual length read is returned.
*/
SANE_Status
sanei_rts88xx_read_data (SANE_Int devnum, SANE_Word * length,
unsigned char *dest)
{
SANE_Status status = SANE_STATUS_GOOD;
SANE_Byte header[4];
size_t size, len, remain, read;
/* do not read too much data */
if (*length > RTS88XX_MAX_XFER_SIZE)
len = RTS88XX_MAX_XFER_SIZE;
else
len = *length;
/* write command header first */
header[0] = 0x91;
header[1] = 0x00;
header[2] = HIBYTE (len);
header[3] = LOBYTE (len);
size = 4;
status = sanei_usb_write_bulk (devnum, header, &size);
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error, "sanei_rts88xx_read_data: failed to write header\n");
}
read = 0;
/* first read blocks aligned on 64 bytes boundary */
while (len - read > 64)
{
size = (len - read) & 0xFFC0;
status = sanei_usb_read_bulk (devnum, dest + read, &size);
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error, "sanei_rts88xx_read_data: failed to read data\n");
return status;
}
DBG (DBG_io2, "sanei_rts88xx_read_data: read %lu bytes\n",
(u_long) size);
read += size;
}
/* then read remainder */
remain = len - read;
if (remain > 0)
{
status = sanei_usb_read_bulk (devnum, dest + read, &remain);
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error, "sanei_rts88xx_read_data: failed to read data\n");
return status;
}
DBG (DBG_io2, "sanei_rts88xx_read_data: read %lu bytes\n",
(u_long) remain);
read += remain;
}
/* update actual read length */
DBG (DBG_io, "sanei_rts88xx_read_data: read %lu bytes, %d required\n",
(u_long) read, *length);
*length = read;
return status;
}
/*******************************************************************************
* USB-in-USB: bulk read
*
* Parameters
* dn - sanei_usb device descriptor
* bytes - pointer to data buffer
* size - size of data to read
* state - pointer to initialized bulk read state structure
*/
static SANE_Status
hp5590_bulk_read (SANE_Int dn,
enum proto_flags proto_flags,
unsigned char *bytes, unsigned int size,
void *state)
{
struct usb_in_usb_bulk_setup ctrl;
SANE_Status ret;
unsigned int next_pages;
uint8_t bulk_flags;
size_t next_portion;
struct bulk_read_state *bulk_read_state;
unsigned int bytes_until_buffer_end;
DBG (3, "%s\n", __func__);
hp5590_low_assert (state != NULL);
hp5590_low_assert (bytes != NULL);
bulk_read_state = state;
if (bulk_read_state->initialized == 0)
{
DBG (DBG_err, "%s: USB-in-USB: bulk read state not initialized\n",
__func__);
return SANE_STATUS_INVAL;
}
memset (bytes, 0, size);
/* Check if requested data would fit into the buffer */
if (size > bulk_read_state->buffer_size)
{
DBG (DBG_err, "Data requested won't fit in the bulk read buffer "
"(requested: %u, buffer size: %u\n", size,
bulk_read_state->buffer_size);
return SANE_STATUS_NO_MEM;
}
/* Read data until requested size of data will be received */
while (bulk_read_state->bytes_available < size)
{
DBG (DBG_usb, "%s: USB-in-USB: not enough data in buffer available "
"(available: %u, requested: %u)\n",
__func__, bulk_read_state->bytes_available, size);
/* IMPORTANT! 'next_pages' means 'request and receive next_pages pages in
* one bulk transfer request '. Windows driver uses 4 pages between each
* request. The more pages are received between requests the less the
* scanner does scan head re-positioning thus improving scanning speed.
* On the other hand, scanner expects that all of the requested pages
* will be received immediately after the request. In case when a
* frontend will have a delay between reads we will get bulk transfer
* timeout sooner or later.
* Having next_pages = 1 is the most safe case.
*/
next_pages = 1;
/* Count all received pages to calculate when we will need to send
* another bulk request
*/
bulk_read_state->total_pages++;
DBG (DBG_usb, "%s: USB-in-USB: total pages done: %u\n",
__func__, bulk_read_state->total_pages);
/* Send another bulk request for 'next_pages' before first
* page or next necessary one
*/
if ( bulk_read_state->total_pages == 1
|| bulk_read_state->total_pages % next_pages == 0)
{
/* Send bulk flags */
DBG (DBG_usb, "%s: USB-in-USB: sending USB-in-USB bulk flags\n",
__func__);
bulk_flags = 0x24;
ret = sanei_usb_control_msg (dn, USB_DIR_OUT | USB_TYPE_VENDOR,
0x0c, 0x83, 0x00,
sizeof (bulk_flags), &bulk_flags);
if (ret != SANE_STATUS_GOOD)
{
DBG (DBG_err, "%s: USB-in-USB: error sending bulk flags\n",
__func__);
return ret;
}
/* USB-in-USB: checking confirmation for bulk flags\n" */
ret = hp5590_get_ack (dn, proto_flags);
if (ret != SANE_STATUS_GOOD)
return ret;
/* Prepare bulk read request */
memset (&ctrl, 0, sizeof (ctrl));
ctrl.bRequestType = 0x00;
ctrl.bEndpoint = 0x82;
ctrl.wLength = htons (next_pages);
/* Send bulk read request */
DBG (DBG_usb, "%s: USB-in-USB: sending control msg for bulk\n",
__func__);
ret = sanei_usb_control_msg (dn, USB_DIR_OUT | USB_TYPE_VENDOR,
0x04, 0x82, 0x00,
sizeof (ctrl),
(unsigned char *) &ctrl);
if (ret != SANE_STATUS_GOOD)
{
DBG (DBG_err, "%s: USB-in-USB: error sending control msg\n",
__func__);
return ret;
}
/* USB-in-USB: checking if control msg was accepted */
ret = hp5590_get_ack (dn, proto_flags);
if (ret != SANE_STATUS_GOOD)
return ret;
}
next_portion = BULK_READ_PAGE_SIZE;
/* Check if next page will fit into the buffer */
if (bulk_read_state->buffer_size
- bulk_read_state->bytes_available < next_portion)
{
DBG (DBG_err, "%s: USB-in-USB: buffer too small\n", __func__);
return SANE_STATUS_NO_MEM;
}
/* Bulk read next page */
DBG (DBG_usb, "%s: USB-in-USB: bulk reading %lu bytes\n",
__func__, (u_long) next_portion);
ret = sanei_usb_read_bulk (dn,
bulk_read_state->buffer_in_ptr,
&next_portion);
if (ret != SANE_STATUS_GOOD)
{
if (ret == SANE_STATUS_EOF)
return ret;
DBG (DBG_err, "%s: USB-in-USB: error during bulk read: %s\n",
__func__, sane_strstatus (ret));
return ret;
}
/* Check if we received the same amount of data as requsted */
if (next_portion != BULK_READ_PAGE_SIZE)
{
DBG (DBG_err, "%s: USB-in-USB: incomplete bulk read "
"(requested %u bytes, got %lu bytes)\n",
__func__, BULK_READ_PAGE_SIZE, (u_long) next_portion);
return SANE_STATUS_IO_ERROR;
}
/* Move pointers to the next position */
bulk_read_state->buffer_in_ptr += next_portion;
/* Check for the end of the buffer */
if (bulk_read_state->buffer_in_ptr > bulk_read_state->buffer_end_ptr)
{
DBG (DBG_err,
"%s: USB-in-USB: attempted to access over the end of buffer "
"(in_ptr: %p, end_ptr: %p, ptr: %p, buffer size: %u\n",
__func__, bulk_read_state->buffer_in_ptr,
bulk_read_state->buffer_end_ptr, bulk_read_state->buffer,
bulk_read_state->buffer_size);
return SANE_STATUS_NO_MEM;
}
/* Check for buffer pointer wrapping */
if (bulk_read_state->buffer_in_ptr == bulk_read_state->buffer_end_ptr)
{
DBG (DBG_usb, "%s: USB-in-USB: buffer wrapped while writing\n",
__func__);
bulk_read_state->buffer_in_ptr = bulk_read_state->buffer;
}
/* Count the amount of data we read */
bulk_read_state->bytes_available += next_portion;
}
/* Transfer requested amount of data to the caller */
DBG (DBG_usb, "%s: USB-in-USB: data in bulk buffer is available "
"(requested %u bytes, available %u bytes)\n",
__func__, size, bulk_read_state->bytes_available);
/* Check for buffer pointer wrapping */
bytes_until_buffer_end = bulk_read_state->buffer_end_ptr
- bulk_read_state->buffer_out_ptr;
if (bytes_until_buffer_end <= size)
{
/* First buffer part */
DBG (DBG_usb, "%s: USB-in-USB: reached bulk read buffer end\n", __func__);
memcpy (bytes, bulk_read_state->buffer_out_ptr, bytes_until_buffer_end);
bulk_read_state->buffer_out_ptr = bulk_read_state->buffer;
/* And second part (if any) */
if (bytes_until_buffer_end < size)
{
DBG (DBG_usb, "%s: USB-in-USB: giving 2nd buffer part\n", __func__);
memcpy (bytes + bytes_until_buffer_end,
bulk_read_state->buffer_out_ptr,
size - bytes_until_buffer_end);
bulk_read_state->buffer_out_ptr += size - bytes_until_buffer_end;
}
}
else
{
/* The data is in one buffer part (w/o wrapping) */
memcpy (bytes, bulk_read_state->buffer_out_ptr, size);
bulk_read_state->buffer_out_ptr += size;
if (bulk_read_state->buffer_out_ptr == bulk_read_state->buffer_end_ptr)
{
DBG (DBG_usb, "%s: USB-in-USB: buffer wrapped while reading\n",
__func__);
bulk_read_state->buffer_out_ptr = bulk_read_state->buffer;
}
}
/* Count the amount of data transferred to the caller */
bulk_read_state->bytes_available -= size;
return SANE_STATUS_GOOD;
}
/* Send command via USB, and get response data */
SANE_Status
kv_usb_escape (PKV_DEV dev,
PKV_CMD_HEADER header, unsigned char *status_byte)
{
int got_response = 0;
size_t len;
unsigned char cmd_buff[24];
memset (cmd_buff, 0, 24);
cmd_buff[3] = 0x18; /* container length */
cmd_buff[5] = 1; /* container type: command block */
cmd_buff[6] = 0x90; /* code */
if (!kv_usb_already_open(dev))
{
DBG (DBG_error, "kv_usb_escape: error, device not open.\n");
return SANE_STATUS_IO_ERROR;
}
memcpy (cmd_buff + 12, header->cdb, header->cdb_size);
/* change timeout */
sanei_usb_set_timeout(KV_CMD_TIMEOUT);
/* Send command */
len = 24;
if (sanei_usb_write_bulk (dev->usb_fd, (SANE_Byte *) cmd_buff, &len))
{
DBG (DBG_error, "usb_bulk_write: Error writing command.\n");
hexdump (DBG_error, "cmd block", cmd_buff, 24);
return SANE_STATUS_IO_ERROR;
}
/* Send / Read data */
if (header->direction == KV_CMD_IN)
{
size_t size = header->data_size + 12;
size_t size_read = size;
unsigned char *data = ((unsigned char *) header->data) - 12;
SANE_Status ret;
ret = sanei_usb_read_bulk (dev->usb_fd, (SANE_Byte *) data, &size_read);
/*empty read is ok?*/
if (ret == SANE_STATUS_EOF){
sanei_usb_clear_halt (dev->usb_fd);
ret = SANE_STATUS_GOOD;
}
if (ret) {
sanei_usb_clear_halt (dev->usb_fd);
DBG (DBG_error, "usb_bulk_read: Error reading data.\n");
return SANE_STATUS_IO_ERROR;
}
if (size_read != size)
{
DBG (DBG_shortread, "usb_bulk_read: Warning - short read\n");
DBG (DBG_shortread, "usb_bulk_read: bytes to read = %lu\n", (unsigned long)size);
DBG (DBG_shortread,
"usb_bulk_read: bytes actual read = %lu\n", (unsigned long)size_read);
/*hexdump (DBG_shortread, "data", data, size_read); */
}
}
if (header->direction == KV_CMD_OUT)
{
size_t size = header->data_size + 12;
size_t size_written = size;
unsigned char *data = ((unsigned char *) header->data) - 12;
SANE_Status ret;
memset (data, 0, 12);
Ito32 (size, data);
data[5] = 0x02; /* container type: data block */
data[6] = 0xb0; /* code */
ret = sanei_usb_write_bulk (dev->usb_fd, (SANE_Byte *) data, &size_written);
/*empty write is ok?*/
if (ret == SANE_STATUS_EOF){
sanei_usb_clear_halt (dev->usb_fd);
ret = SANE_STATUS_GOOD;
}
if (ret) {
sanei_usb_clear_halt (dev->usb_fd);
DBG (DBG_error, "usb_bulk_write: Error writing data.\n");
return SANE_STATUS_IO_ERROR;
}
if (size_written != size)
{
DBG (DBG_shortread, "usb_bulk_write: Warning - short written\n");
DBG (DBG_shortread, "usb_bulk_write: bytes to write = %lu\n", (unsigned long)size);
DBG (DBG_shortread,
"usb_bulk_write: bytes actual written = %lu\n", (unsigned long)size_written);
hexdump (DBG_shortread, "data", data, size_written);
}
}
/* Get response */
if (!got_response)
{
SANE_Status ret;
size_t len = 16;
ret = sanei_usb_read_bulk (dev->usb_fd, (SANE_Byte *) cmd_buff, &len);
if (ret || len != 16)
{
DBG (DBG_error, "usb_bulk_read: Error reading response."
" read %lu bytes\n", (unsigned long)len);
sanei_usb_clear_halt (dev->usb_fd);
return SANE_STATUS_IO_ERROR;
}
}
if (cmd_buff[5] != 3)
{
DBG (DBG_error, "usb_bulk_read: Invalid response block.\n");
hexdump (DBG_error, "response", cmd_buff, 16);
return SANE_STATUS_IO_ERROR;
}
*status_byte = cmd_buff[15] & 0x3E;
return SANE_STATUS_GOOD;
}
