From cfd27ef2ad8b005fd47ab41ef29b71d9e3d48201 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?J=C3=B6rg=20Frings-F=C3=BCrst?= Date: Thu, 8 Oct 2015 12:32:49 +0200 Subject: Imported Upstream version 1.0.25 --- backend/pieusb_usb.c | 679 +++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 679 insertions(+) create mode 100644 backend/pieusb_usb.c (limited to 'backend/pieusb_usb.c') diff --git a/backend/pieusb_usb.c b/backend/pieusb_usb.c new file mode 100644 index 0000000..71b6bcf --- /dev/null +++ b/backend/pieusb_usb.c @@ -0,0 +1,679 @@ +/* sane - Scanner Access Now Easy. + + pieusb_usb.c + + Copyright (C) 2012-2015 Jan Vleeshouwers, Michael Rickmann, Klaus Kaempf + + 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. */ + +#define DEBUG_DECLARE_ONLY +#include "pieusb.h" +#include "pieusb_scancmd.h" +#include "pieusb_usb.h" + +#include "../include/sane/sanei_usb.h" +#include /* usleep */ +#include /* time */ + +/* USB functions */ + +static SANE_Status _ctrl_out_byte(SANE_Int device_number, SANE_Int port, SANE_Byte b); +static SANE_Status _bulk_size(SANE_Int device_number, unsigned int size); +static SANE_Status _ctrl_in_byte(SANE_Int device_number, SANE_Byte* b); +static SANE_Status _bulk_in(SANE_Int device_number, SANE_Byte* data, size_t *size); +static SANE_Status _ieee_command(SANE_Int device_number, SANE_Byte command); + +/* Defines for use in USB functions */ + +#define REQUEST_TYPE_IN (USB_TYPE_VENDOR | USB_DIR_IN) +#define REQUEST_TYPE_OUT (USB_TYPE_VENDOR | USB_DIR_OUT) +#define REQUEST_REGISTER 0x0c +#define REQUEST_BUFFER 0x04 +#define ANYINDEX 0x00 /* wIndex value for USB control transfer - value is irrelevant */ + +/* from libieee1284 */ +#define C1284_NSTROBE 0x01 +#define C1284_NINIT 0x04 + +/* usb via ieee1284 */ +#define IEEE1284_ADDR 0x00 +#define IEEE1284_RESET 0x30 +#define IEEE1284_SCSI 0xe0 + +#define PORT_SCSI_SIZE 0x0082 +#define PORT_SCSI_STATUS 0x0084 +#define PORT_SCSI_CMD 0x0085 +#define PORT_PAR_CTRL 0x0087 /* IEEE1284 parallel control */ +#define PORT_PAR_DATA 0x0088 /* IEEE1284 parallel data */ + +/* see also: SCSI Status Codes http://www.t10.org/lists/2status.htm */ +typedef enum { + USB_STATUS_OK = 0x00, /* ok */ + USB_STATUS_READ = 0x01, /* read: send expected length, then read data */ + USB_STATUS_CHECK = 0x02, /* check condition */ + USB_STATUS_BUSY = 0x03, /* wait on usb */ + USB_STATUS_AGAIN = 0x08, /* re-send scsi cmd */ + USB_STATUS_FAIL = 0x88, /* ??? */ + USB_STATUS_ERROR = 0xff /* usb i/o error */ +} PIEUSB_USB_Status; + +static PIEUSB_USB_Status _pieusb_scsi_command(SANE_Int device_number, SANE_Byte command[], SANE_Byte data[], SANE_Int size); + +#define SENSE_CODE_WARMING_UP 4 + +/* Standard SCSI Sense codes*/ +#define SCSI_NO_ADDITIONAL_SENSE_INFORMATION 0x00 + +struct code_text_t { int code; char *text; }; +static struct code_text_t usb_code_text[] = { + { 0x00, "Ok" }, + { 0x01, "Read" }, + { 0x02, "Check" }, + { 0x03, "Busy" }, + { 0x08, "Again" }, + { 0xff, "Error" }, + { -1, NULL } +}; + +static struct code_text_t scsi_code_text[] = { + { 0x00, "Test Unit Ready" } + ,{ 0x01, "Calibrate" } + ,{ 0x03, "Request Sense" } + ,{ 0x04, "Format" } + ,{ 0x08, "Read" } + ,{ 0x0a, "Write" } + ,{ 0x0f, "Get Param" } + ,{ 0x10, "Mark" } + ,{ 0x11, "Space" } + ,{ 0x12, "Inquiry" } + ,{ 0x15, "Mode Select" } + ,{ 0x16, "Reserve Unit" } + ,{ 0x18, "Copy" } + ,{ 0x1a, "Mode Sense" } + ,{ 0x1b, "Scan" } + ,{ 0x1d, "Diagnose" } + ,{ 0xa8, "Read Extended" } + ,{ 0xd1, "Slide" } + ,{ 0xd2, "Set Scan Head" } + ,{ 0xd7, "Read Gain Offset" } + ,{ 0xdc, "Write Gain Offset" } + ,{ 0xdd, "Read State" } + ,{ -1, NULL } +}; + +static char * +code_to_text(struct code_text_t *list, int code) +{ + while (list && list->text) { + if (list->code == code) + return list->text; + list++; + } + return "**unknown**"; +} + +/** + * Convert PIEUSB_Status to SANE_Status + */ +SANE_Status +sanei_pieusb_convert_status(PIEUSB_Status status) +{ + return (SANE_Status)status; +} + + +/** + * hex dump 'size' bytes starting at 'ptr' + */ +static void +_hexdump(char *msg, unsigned char *ptr, int size) +{ + unsigned char *lptr = ptr; + int count = 0; + long start = 0; + long clipped = 0; + + if (DBG_info_proc > DBG_LEVEL) + return; + + if (size > 127) { + clipped = size; + size = 128; + } + while (size-- > 0) + { + if ((count % 16) == 0) + fprintf (stderr, "%s\t%08lx:", msg?msg:"", start); + msg = NULL; + fprintf (stderr, " %02x", *ptr++); + count++; + start++; + if (size == 0) + { + while ((count % 16) != 0) + { + fprintf (stderr, " "); + count++; + } + } + if ((count % 16) == 0) + { + fprintf (stderr, " "); + while (lptr < ptr) + { + unsigned char c = *lptr & 0x7f; + fprintf (stderr, "%c", ((c < 0x20)||(c == 0x7f)) ? '.' : c); + lptr++; + } + fprintf (stderr, "\n"); + } + } + if ((count % 16) != 0) + fprintf (stderr, "\n"); + if (clipped > 0) + fprintf (stderr, "\t%08lx bytes clipped\n", clipped); + + fflush(stderr); + return; +} + + +/* ========================================================================= + * + * USB functions + * + * ========================================================================= */ + +/** + * Send a command to the device, retry 10 times if device is busy + * and return SENSE data in the sense fields of status if there is a CHECK + * CONDITION response from the command. + * If the REQUEST SENSE command fails, the SANE status code is unequal to + * PIEUSB_STATUS_GOOD and the sense fields are empty. + * + * @param device_number Device number + * @param command Command array + * @param data Input or output data buffer + * @param size Size of the data buffer + * @param status Pieusb_Command_Status + */ + +PIEUSB_Status +sanei_pieusb_command(SANE_Int device_number, SANE_Byte command[], SANE_Byte data[], SANE_Int size) +{ +#define MAXTIME 60 /* max 60 seconds */ + time_t start; + SANE_Status sane_status; + PIEUSB_Status ret = PIEUSB_STATUS_DEVICE_BUSY; + SANE_Byte usbstat; + PIEUSB_USB_Status usb_status = USB_STATUS_AGAIN; + + DBG (DBG_info_usb, "*** sanei_pieusb_command(%02x:%s): size 0x%02x\n", command[0], code_to_text (scsi_code_text, command[0]), size); + + start = time(NULL); + while ((time(NULL)-start) < MAXTIME) { + DBG (DBG_info_usb, "\tsanei_pieusb_command loop, status %d:%s\n", usb_status, code_to_text (usb_code_text, usb_status)); + if (usb_status == USB_STATUS_AGAIN) { + usb_status = _pieusb_scsi_command (device_number, command, data, size); + DBG (DBG_info_usb, "\t_pieusb_scsi_command returned %d:%s\n", usb_status, code_to_text (usb_code_text, usb_status)); + continue; + } + if (usb_status == USB_STATUS_OK) { + ret = PIEUSB_STATUS_GOOD; + break; + } + if (usb_status == USB_STATUS_READ) { + DBG (DBG_error, "\tsanei_pieusb_command() 2nd STATUS_READ ?!\n"); + ret = PIEUSB_STATUS_IO_ERROR; + break; + } + if (usb_status == USB_STATUS_CHECK) { + /* check condition */ + struct Pieusb_Sense sense; + struct Pieusb_Command_Status senseStatus; + +#define SCSI_REQUEST_SENSE 0x03 + + if (command[0] == SCSI_REQUEST_SENSE) { + DBG (DBG_error, "\tsanei_pieusb_command() recursive SCSI_REQUEST_SENSE\n"); + ret = PIEUSB_STATUS_INVAL; + break; + } + + /* A check sense may be a busy state in disguise + * It is also practical to execute a request sense command by + * default. The calling function should interpret + * PIEUSB_STATUS_CHECK_SENSE as 'sense data available'. */ + + sanei_pieusb_cmd_get_sense (device_number, &sense, &senseStatus, &ret); + if (senseStatus.pieusb_status != PIEUSB_STATUS_GOOD) { + DBG (DBG_error, "\tsanei_pieusb_command(): CHECK CONDITION, but REQUEST SENSE fails\n"); + ret = senseStatus.pieusb_status; + } + break; + } + if (usb_status == USB_STATUS_BUSY) { + /* wait on usb */ + sane_status = _ctrl_in_byte (device_number, &usbstat); + if (sane_status != SANE_STATUS_GOOD) { + DBG (DBG_error, "\tpieusb_scsi_command() fails status in: %d\n", sane_status); + ret = PIEUSB_STATUS_IO_ERROR; + break; + } + usb_status = usbstat; + if (usb_status == USB_STATUS_AGAIN) { + sleep(1); + } + continue; + } + if (usb_status == USB_STATUS_AGAIN) { + /* re-send scsi cmd */ + continue; + } + if (usb_status == USB_STATUS_FAIL) { + DBG (DBG_error, "\tsanei_pieusb_command() usb status again2\n"); + usb_status = USB_STATUS_ERROR; + sanei_pieusb_usb_reset(device_number); + ret = PIEUSB_STATUS_IO_ERROR; + break; + } + if (usb_status == USB_STATUS_ERROR) { + sanei_pieusb_usb_reset(device_number); + ret = PIEUSB_STATUS_IO_ERROR; + break; + } + + DBG (DBG_error, "\tsanei_pieusb_command() unhandled usb status 0x%02x\n", usb_status); + ret = PIEUSB_STATUS_IO_ERROR; + break; + } + if ((time(NULL)-start) > MAXTIME) { + DBG (DBG_info_usb, "\tsanei_pieusb_command() timeout !\n"); + } + + DBG (DBG_info_usb, "\tsanei_pieusb_command() finished with state %d\n", ret); + return ret; +} + +/** + * Reset IEEE1284 interface + * + * @param device_number Device number + * @returns SANE_Status + */ + +SANE_Status +sanei_pieusb_usb_reset(SANE_Int device_number) +{ + DBG (DBG_info_sane, "\tsanei_pieusb_usb_reset()\n"); + return _ieee_command (device_number, IEEE1284_RESET); +} + +/* http://www.t10.org/lists/2sensekey.htm */ +static struct code_text_t sense_code_text[] = { + { SCSI_SENSE_NO_SENSE, "No Sense" }, + { SCSI_SENSE_RECOVERED_ERROR, "Recovered Error" }, + { SCSI_SENSE_NOT_READY, "Not Ready" }, + { SCSI_SENSE_MEDIUM_ERROR, "Medium Error" }, + { SCSI_SENSE_HARDWARE_ERROR, "Hardware Error" }, + { SCSI_SENSE_ILLEGAL_REQUEST, "Illegal Request" }, + { SCSI_SENSE_UNIT_ATTENTION, "Unit Attention" }, + { SCSI_SENSE_DATA_PROTECT, "Data Protect" }, + { SCSI_SENSE_BLANK_CHECK, "Blank Check" }, + { SCSI_SENSE_VENDOR_SPECIFIC, "Vendor Specific" }, + { SCSI_SENSE_COPY_ABORTED, "Copy Aborted" }, + { SCSI_SENSE_ABORTED_COMMAND, "Aborted Command" }, + { SCSI_SENSE_EQUAL, "Equal" }, + { SCSI_SENSE_VOLUME_OVERFLOW, "Volume Overflow" }, + { SCSI_SENSE_MISCOMPARE, "Miscompare" }, + { SCSI_SENSE_COMPLETED, "Completed" }, + { -1, NULL } +}; + + +/** + * Return a textual description of the given sense code. + * + * See http://www.t10.org/lists/asc-num.txt + * + * @param sense + * @return description + */ + +SANE_String +sanei_pieusb_decode_sense(struct Pieusb_Sense* sense, PIEUSB_Status *status) +{ + SANE_Char* desc = malloc(200); + SANE_Char* ptr; + strcpy (desc, code_to_text (sense_code_text, sense->senseKey)); + ptr = desc + strlen(desc); + + switch (sense->senseKey) { + case SCSI_SENSE_NOT_READY: + if (sense->senseCode == SENSE_CODE_WARMING_UP && sense->senseQualifier == 1) { + strcpy (ptr, ": Logical unit is in the process of becoming ready"); + *status = PIEUSB_STATUS_WARMING_UP; + } + else { + sprintf (ptr, ": senseCode 0x%02x, senseQualifier 0x%02x", sense->senseCode, sense->senseQualifier); + *status = PIEUSB_STATUS_INVAL; + } + break; + case SCSI_SENSE_UNIT_ATTENTION: + if (sense->senseCode == 0x1a && sense->senseQualifier == 0) { + strcpy (ptr, ": Invalid field in parameter list"); + *status = PIEUSB_STATUS_INVAL; + break; + } else if (sense->senseCode == 0x20 && sense->senseQualifier == 0) { + strcpy (ptr, ": Invalid command operation code"); + *status = PIEUSB_STATUS_INVAL; + break; + } else if (sense->senseCode == 0x82 && sense->senseQualifier == 0) { + strcpy (ptr, ": Calibration disable not granted"); + *status = PIEUSB_STATUS_MUST_CALIBRATE; + break; + } else if (sense->senseCode == 0x00 && sense->senseQualifier == 6) { + strcpy (ptr, ": I/O process terminated"); + *status = PIEUSB_STATUS_IO_ERROR; + break; + } else if (sense->senseCode == 0x26 && sense->senseQualifier == 0x82) { + strcpy (ptr, ": MODE SELECT value invalid: resolution too high (vs)"); + *status = PIEUSB_STATUS_INVAL; + break; + } else if (sense->senseCode == 0x26 && sense->senseQualifier == 0x83) { + strcpy (ptr, ": MODE SELECT value invalid: select only one color (vs)"); + *status = PIEUSB_STATUS_INVAL; + break; + } else if (sense->senseCode == 0x26 && sense->senseQualifier == 0x83) { + strcpy (ptr, ": MODE SELECT value invalid: unsupported bit depth (vs)"); + *status = PIEUSB_STATUS_INVAL; + break; + } + /*fallthru*/ + case SCSI_SENSE_NO_SENSE: + case SCSI_SENSE_RECOVERED_ERROR: + case SCSI_SENSE_MEDIUM_ERROR: + case SCSI_SENSE_HARDWARE_ERROR: + case SCSI_SENSE_ILLEGAL_REQUEST: + case SCSI_SENSE_DATA_PROTECT: + case SCSI_SENSE_BLANK_CHECK: + case SCSI_SENSE_VENDOR_SPECIFIC: + case SCSI_SENSE_COPY_ABORTED: + case SCSI_SENSE_ABORTED_COMMAND: + case SCSI_SENSE_EQUAL: + case SCSI_SENSE_VOLUME_OVERFLOW: + case SCSI_SENSE_MISCOMPARE: + case SCSI_SENSE_COMPLETED: + default: + sprintf (ptr, ": senseCode 0x%02x, senseQualifier 0x%02x", sense->senseCode, sense->senseQualifier); + *status = PIEUSB_STATUS_INVAL; + } + return desc; +} + +/** + * Prepare IEEE1284 interface + * Issue one of IEEE1284_ADDR, IEEE1284_RESET, or IEEE1284_SCSI + * + * @param device_number Device number + * @param command - IEEE1284 command + * @returns SANE_Status + */ + +static SANE_Status +_ieee_command(SANE_Int device_number, SANE_Byte command) +{ + SANE_Status st; + static int sequence[] = { 0xff, 0xaa, 0x55, 0x00, 0xff, 0x87, 0x78 }; +#define SEQUENCE_LEN 7 + unsigned int i; + /* 2 x 4 + 3 bytes preceding command, then SCSI_COMMAND_LEN bytes command */ + /* IEEE1284 command, see hpsj5s.c:cpp_daisy() */ + for (i = 0; i < SEQUENCE_LEN; ++i) { + st = _ctrl_out_byte (device_number, PORT_PAR_DATA, sequence[i]); + if (st != SANE_STATUS_GOOD) { + DBG (DBG_error, "\t\t_ieee_command fails after %d bytes\n", i); + return st; + } + } + st = _ctrl_out_byte (device_number, PORT_PAR_DATA, command); + if (st == SANE_STATUS_GOOD) { + usleep(3000); /* 3.000 usec -> 3 msec */ + st = _ctrl_out_byte (device_number, PORT_PAR_CTRL, C1284_NINIT|C1284_NSTROBE); /* CTRL_VAL_FINAL */ + if (st == SANE_STATUS_GOOD) { + st = _ctrl_out_byte (device_number, PORT_PAR_CTRL, C1284_NINIT); + if (st == SANE_STATUS_GOOD) { + st = _ctrl_out_byte (device_number, PORT_PAR_DATA, 0xff); + if (st != SANE_STATUS_GOOD) { + DBG (DBG_error, "\t\t_ieee_command fails to write final data\n"); + } + } + else { + DBG (DBG_error, "\t\t_ieee_command fails to reset strobe\n"); + } + } + else { + DBG (DBG_error, "\t\t_ieee_command fails to set strobe\n"); + } + } + + return st; +#undef SEQUENCE_LEN +} + +/** + * Send a command to the device. + * The command is a SCSI_COMMAND_LEN-byte array. The data-array is used for input and output. + * The sense-fields of Pieusb_Command_Status are cleared. + * + * @param device_number Device number + * @param command Command array + * @param data Input or output data buffer + * @param size Size of the data buffer + * @returns PIEUSB_SCSI_Status + */ +static PIEUSB_USB_Status +_pieusb_scsi_command(SANE_Int device_number, SANE_Byte command[], SANE_Byte data[], SANE_Int size) +{ + SANE_Status st; + SANE_Byte usbstat; + int i; + + DBG (DBG_info_usb, "\t\t_pieusb_scsi_command(): %02x:%s\n", command[0], code_to_text (scsi_code_text, command[0])); + + st = _ieee_command (device_number, IEEE1284_SCSI); + if (st != SANE_STATUS_GOOD) { + DBG (DBG_error, "\t\t_pieusb_scsi_command can't prep scsi cmd: %d\n", st); + return USB_STATUS_ERROR; + } + + /* output command */ + for (i = 0; i < SCSI_COMMAND_LEN; ++i) { + SANE_Status st; + st = _ctrl_out_byte (device_number, PORT_SCSI_CMD, command[i]); + if (st != SANE_STATUS_GOOD) { + DBG (DBG_error, "\t\t_pieusb_scsi_command fails command out, after %d bytes: %d\n", i, st); + return USB_STATUS_ERROR; + } + } + _hexdump ("Cmd", command, SCSI_COMMAND_LEN); + + /* Verify this sequence */ + st = _ctrl_in_byte (device_number, &usbstat); + if (st != SANE_STATUS_GOOD) { + DBG (DBG_error, "\t\t_pieusb_scsi_command fails status after command out: %d\n", st); + return USB_STATUS_ERROR; + } + /* Process rest of the data, if present; either input or output, possibly bulk */ + DBG (DBG_info_usb, "\t\t_pieusb_scsi_command usbstat 0x%02x\n", usbstat); + if (usbstat == USB_STATUS_OK && size > 0) { + /* + * send additional data to usb + */ + _hexdump ("Out", data, size); + for (i = 0; i < size; ++i) { + st = _ctrl_out_byte (device_number, PORT_SCSI_CMD, data[i]); + if (st != SANE_STATUS_GOOD) { + DBG (DBG_error, "\t\t_pieusb_scsi_command fails data out after %d bytes: %d\n", i, st); + return USB_STATUS_ERROR; + } + } + /* Verify data out */ + st = _ctrl_in_byte (device_number, &usbstat); + if (st != SANE_STATUS_GOOD) { + DBG (DBG_error, "\t\t_pieusb_scsi_command fails status after data out: %d\n", st); + return USB_STATUS_ERROR; + } + } + else if (usbstat == USB_STATUS_READ) { + /* Intermediate status OK, device has made data available for reading */ + /* Read data */ + size_t remsize; + size_t partsize; + + remsize = (size_t)size; + + DBG (DBG_info_usb, "\t\t_pieusb_scsi_command data in\n"); + while (remsize > 0) { + partsize = remsize > 0x1000000 ? 0x1000000 : remsize; /* 0xc000 must be multiples of 0x4000, see _bulk_in() */ + /* send expected length */ + st = _bulk_size (device_number, partsize); + if (st != SANE_STATUS_GOOD) { + DBG (DBG_error, "\t\t_pieusb_scsi_command prepare read data failed for size %u: %d\n", (unsigned int)partsize, st); + return USB_STATUS_ERROR; + } + /* read expected length bytes */ + st = _bulk_in (device_number, data + size - remsize, &partsize); + if (st != SANE_STATUS_GOOD) { + DBG (DBG_error, "\t\t_pieusb_scsi_command read data failed for size %u: %d\n", (unsigned int)partsize, st); + return USB_STATUS_ERROR; + } + remsize -= partsize; +/* DBG (DBG_info, "\t\t_pieusb_scsi_command partsize %08x, remsize %08x\n", (unsigned int)partsize, (unsigned int)remsize); */ + } + /* Verify data in */ + st = _ctrl_in_byte (device_number, &usbstat); + if (st != SANE_STATUS_GOOD) { + DBG (DBG_error, "\t\t_pieusb_scsi_command fails status after data in: %d\n", st); + return USB_STATUS_ERROR; + } + _hexdump ("In", data, size); + } + + return usbstat; +} + + +/** + * Simplified control transfer: one byte to given port + * + * @param device_number device number + * @param b byte to send to device + * @return SANE status + */ +static SANE_Status _ctrl_out_byte(SANE_Int device_number, SANE_Int port, SANE_Byte b) { + /* int r = libusb_control_transfer(scannerHandle, CTRL_OUT, 0x0C, 0x0088, ANYINDEX, &b, 1, TIMEOUT); */ + return sanei_usb_control_msg(device_number, REQUEST_TYPE_OUT, REQUEST_REGISTER, port, ANYINDEX, 1, &b); +} + + +/** + * Simplified control transfer for port/wValue = 0x82 - prepare bulk + * + * @param device_number device number + * @param size Size of bulk transfer which follows (number of bytes) + * @return SANE status + */ +static SANE_Status _bulk_size(SANE_Int device_number, unsigned int size) { + SANE_Byte bulksize[] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; + bulksize[4] = size & 0xff; + bulksize[5] = (size >> 8) & 0xff; + bulksize[6] = (size >> 16) & 0xff; + bulksize[7] = (size >> 24) & 0xff; + return sanei_usb_control_msg(device_number, REQUEST_TYPE_OUT, REQUEST_BUFFER, PORT_SCSI_SIZE, ANYINDEX, 8, bulksize); +} + + +/* + * Ctrl inbound, single byte + */ +/** + * Inbound control transfer + * + * @param device_number device number + * @param b byte received from device + * @return SANE status + */ +static SANE_Status _ctrl_in_byte(SANE_Int device_number, SANE_Byte* b) { + /* int r = libusb_control_transfer(scannerHandle, CTRL_IN, 0x0C, 0x0084, ANYINDEX, &b, 1, TIMEOUT); */ + /* int r = libusb_control_transfer(scannerHandle, CTRL_IN, 0x0C, 0x0084, ANYINDEX, &b, 1, TIMEOUT); */ + return sanei_usb_control_msg(device_number, REQUEST_TYPE_IN, REQUEST_REGISTER, PORT_SCSI_STATUS, ANYINDEX, 1, b); +} + + +/** + * Bulk in transfer for data, in parts of 0x4000 bytes max + * + * @param device_number device number + * @param data array holding or receiving data (must be preallocated) + * @param size ptr to size of the data array / actual size on output + * @return SANE status + */ +static SANE_Status +_bulk_in(SANE_Int device_number, SANE_Byte *data, size_t *size) { + size_t remaining = 0; + SANE_Status r = SANE_STATUS_GOOD; + size_t part; + + remaining = *size; + while (remaining > 0) { + /* Determine bulk size */ + part = (remaining >= 0x4000) ? 0x4000 : remaining; /* max 16k per chunk */ +/* DBG (DBG_info, "\t\t_bulk_in: %08x @ %p, %08x rem\n", (unsigned int)part, data, (unsigned int)remaining); */ + r = sanei_usb_read_bulk(device_number, data, &part); + if (r != SANE_STATUS_GOOD) { + break; + } +/* DBG (DBG_info, "\t\t_bulk_in: -> %d : %08x\n", r, (unsigned int)part);*/ + remaining -= part; + data += part; + } + *size -= remaining; + return r; +} -- cgit v1.2.3