summaryrefslogtreecommitdiff
path: root/backend/cardscan.c
diff options
context:
space:
mode:
authorJörg Frings-Fürst <debian@jff-webhosting.net>2014-10-06 14:00:40 +0200
committerJörg Frings-Fürst <debian@jff-webhosting.net>2014-10-06 14:00:40 +0200
commit6e9c41a892ed0e0da326e0278b3221ce3f5713b8 (patch)
tree2e301d871bbeeb44aa57ff9cc070fcf3be484487 /backend/cardscan.c
Initial import of sane-backends version 1.0.24-1.2
Diffstat (limited to 'backend/cardscan.c')
-rw-r--r--backend/cardscan.c1686
1 files changed, 1686 insertions, 0 deletions
diff --git a/backend/cardscan.c b/backend/cardscan.c
new file mode 100644
index 0000000..6442458
--- /dev/null
+++ b/backend/cardscan.c
@@ -0,0 +1,1686 @@
+/* sane - Scanner Access Now Easy.
+
+ This file is part of the SANE package, and implements a SANE backend
+ for various Corex Cardscan scanners.
+
+ Copyright (C) 2007-2010 m. allan noah
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License as
+ published by the Free Software Foundation; either version 2 of the
+ License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston,
+ MA 02111-1307, USA.
+
+ As a special exception, the authors of SANE give permission for
+ additional uses of the libraries contained in this release of SANE.
+
+ The exception is that, if you link a SANE library with other files
+ to produce an executable, this does not by itself cause the
+ resulting executable to be covered by the GNU General Public
+ License. Your use of that executable is in no way restricted on
+ account of linking the SANE library code into it.
+
+ This exception does not, however, invalidate any other reasons why
+ the executable file might be covered by the GNU General Public
+ License.
+
+ If you submit changes to SANE to the maintainers to be included in
+ a subsequent release, you agree by submitting the changes that
+ those changes may be distributed with this exception intact.
+
+ If you write modifications of your own for SANE, it is your choice
+ whether to permit this exception to apply to your modifications.
+ If you do not wish that, delete this exception notice.
+
+ --------------------------------------------------------------------------
+
+ This file implements a SANE backend for the Corex Cardscan 800C
+
+ The source code is divided in sections which you can easily find by
+ searching for the tag "@@".
+
+ Section 1 - Init & static stuff
+ Section 2 - sane_init, _get_devices, _open & friends
+ Section 3 - sane_*_option functions
+ Section 4 - sane_start, _get_param, _read & friends
+ Section 5 - sane_close functions
+ Section 6 - misc functions
+
+ Changes:
+ v0, 2007-05-09, MAN (SANE v1.0.19)
+ - initial release
+ v1, 2008-02-14, MAN
+ - sanei_config_read has already cleaned string (#310597)
+ v2, 2010-02-10, MAN
+ - add lines_per_block config option
+ - add has_cal_buffer config option
+ - basic support for 600c
+ - clean #include lines
+
+##################################################
+ DATA FROM TRACE OF WINDOWS DRIVER:
+
+cmd packet format:
+cmdcode cmdlenlow cmdlenhigh cmdpayloadbytes
+
+resp packet format:
+respcode paperfound resplenlow resplenhigh respayloadbytes
+
+############ status read loop? ##################
+>> 01 01 00 00
+<< 81 00 07 00 00 09 0c 61 c2 7a 0a
+>> 34 00 00
+<< b4 00 00 00
+>> 01 01 00 00
+<< 81 00 07 00 00 09 0c 61 c2 7a 0a
+>> 34 00 00
+<< b4 00 00 00
+>> 01 01 00 00
+<< 81 00 07 00 00 09 0c 61 c2 7a 0a
+
+############# scanner settings read? (0x04b8 is scan width) #############
+>> 48 00 00
+<< c8 00 0c 00 b8 04 60 00 00 80 00 00 00 58 ca 7d
+
+############## color and gray calibration data read ############
+>> 45 00 00
+<< 0x2600 bytes, bbbBBBgggGGGrrrRRRxxxXXX
+
+############ 34/b4 and 01/81 status loop til paper inserted ##############
+
+>> 35 01 00 00
+<< b5 01 01 00 00
+
+always together? {
+>> 14 05 00 80 1b 28 00 0f
+<< 94 01 05 00 80 1b 28 00 0f
+>> 22 01 00 00
+<< a2 01 01 00 00
+}
+
+>> 1a 01 00 66
+<< 9a 01 01 00 66
+
+>> 19 03 00 51 62 49
+<< 99 01 03 00 51 62 49
+
+############# heat up lamp? #################
+===========color===================
+three times {
+>> 18 07 00 00 01 60 00 61 00 07
+<< 0x40 read and 0x03 read
+the 3 byte drops from f4 f4 f4 to 17 10 08 etc.
+}
+===========gray===================
+three times {
+>> 12 06 00 00 01 60 00 61 00
+<< 0x40 read and 0x01 read
+}
+the 1 byte drops from f4 to 02
+==================================
+
+>> 35 01 00 00
+<< b5 01 01 00 00
+
+>> 13 01 00 28
+<< 93 01 01 00 28
+
+===========color===================
+three times {
+>> 18 07 00 01 10 60 00 18 05 07
+<< 0xe2c0 read
+}
+
+14/94 and 22/a2
+
+many times {
+>> 18 07 00 01 10 60 00 18 05 07
+<< 0xe2c0 read
+}
+===========gray===================
+two times {
+>> 12 06 00 01 10 60 00 18 05
+<< 0x4bc0 read
+}
+
+14/94 and 22/a2
+
+many times {
+>> 12 06 00 01 10 60 00 18 05
+<< 0x4bc0 read
+}
+==================================
+
+>> 35 01 00 ff
+<< b5 00 01 00 ff
+
+14/94 and 22/a2
+
+########### discarge capacitor? ###########
+four times {
+>> 21 02 00 0a 00
+<< a1 00 02 00 0a 00
+}
+
+>> 01 01 00 00
+<< 81 00 07 00 00 09 0c 61 c2 7a 0a
+
+>> 35 01 00 ff
+<< b5 00 01 00 ff
+
+>> 34 00 00
+<< b4 00 00 00
+#############################################
+
+ SANE FLOW DIAGRAM
+
+ - sane_init() : initialize backend
+ . - sane_get_devices() : query list of scanner devices
+ . - sane_open() : open a particular scanner device
+ . . - sane_set_io_mode : set blocking mode
+ . . - sane_get_select_fd : get scanner fd
+ . .
+ . . - sane_get_option_descriptor() : get option information
+ . . - sane_control_option() : change option values
+ . . - sane_get_parameters() : returns estimated scan parameters
+ . . - (repeat previous 3 functions)
+ . .
+ . . - sane_start() : start image acquisition
+ . . - sane_get_parameters() : returns actual scan parameters
+ . . - sane_read() : read image data (from pipe)
+ . . (sane_read called multiple times; after sane_read returns EOF,
+ . . loop may continue with sane_start which may return a 2nd page
+ . . when doing duplex scans, or load the next page from the ADF)
+ . .
+ . . - sane_cancel() : cancel operation
+ . - sane_close() : close opened scanner device
+ - sane_exit() : terminate use of backend
+
+*/
+
+/*
+ * @@ Section 1 - Init
+ */
+
+#include "../include/sane/config.h"
+
+#include <string.h> /*memcpy...*/
+#include <ctype.h> /*isspace*/
+
+#include "../include/sane/sanei_backend.h"
+#include "../include/sane/sanei_usb.h"
+#include "../include/sane/saneopts.h"
+#include "../include/sane/sanei_config.h"
+
+#include "cardscan.h"
+
+#define DEBUG 1
+#define BUILD 2
+
+/* values for SANE_DEBUG_CARDSCAN env var:
+ - errors 5
+ - function trace 10
+ - function detail 15
+ - get/setopt cmds 20
+ - usb cmd trace 25
+ - usb cmd detail 30
+ - useless noise 35
+*/
+
+int global_has_cal_buffer = 1;
+int global_lines_per_block = 16;
+
+/* ------------------------------------------------------------------------- */
+#define STRING_GRAYSCALE SANE_VALUE_SCAN_MODE_GRAY
+#define STRING_COLOR SANE_VALUE_SCAN_MODE_COLOR
+
+/*
+ * used by attach* and sane_get_devices
+ * a ptr to a null term array of ptrs to SANE_Device structs
+ * a ptr to a single-linked list of scanner structs
+ */
+static const SANE_Device **sane_devArray = NULL;
+static struct scanner *scanner_devList = NULL;
+
+/*
+ * @@ Section 2 - SANE & scanner init code
+ */
+
+/*
+ * Called by SANE initially.
+ *
+ * From the SANE spec:
+ * This function must be called before any other SANE function can be
+ * called. The behavior of a SANE backend is undefined if this
+ * function is not called first. The version code of the backend is
+ * returned in the value pointed to by version_code. If that pointer
+ * is NULL, no version code is returned. Argument authorize is either
+ * a pointer to a function that is invoked when the backend requires
+ * authentication for a specific resource or NULL if the frontend does
+ * not support authentication.
+ */
+SANE_Status
+sane_init (SANE_Int * version_code, SANE_Auth_Callback authorize)
+{
+ authorize = authorize; /* get rid of compiler warning */
+
+ DBG_INIT ();
+ DBG (10, "sane_init: start\n");
+
+ sanei_usb_init();
+
+ if (version_code)
+ *version_code = SANE_VERSION_CODE (SANE_CURRENT_MAJOR, V_MINOR, BUILD);
+
+ DBG (5, "sane_init: cardscan backend %d.%d.%d, from %s\n",
+ SANE_CURRENT_MAJOR, V_MINOR, BUILD, PACKAGE_STRING);
+
+ DBG (10, "sane_init: finish\n");
+
+ return SANE_STATUS_GOOD;
+}
+
+/*
+ * Called by SANE to find out about supported devices.
+ *
+ * From the SANE spec:
+ * This function can be used to query the list of devices that are
+ * available. If the function executes successfully, it stores a
+ * pointer to a NULL terminated array of pointers to SANE_Device
+ * structures in *device_list. The returned list is guaranteed to
+ * remain unchanged and valid until (a) another call to this function
+ * is performed or (b) a call to sane_exit() is performed. This
+ * function can be called repeatedly to detect when new devices become
+ * available. If argument local_only is true, only local devices are
+ * returned (devices directly attached to the machine that SANE is
+ * running on). If it is false, the device list includes all remote
+ * devices that are accessible to the SANE library.
+ *
+ * SANE does not require that this function is called before a
+ * sane_open() call is performed. A device name may be specified
+ * explicitly by a user which would make it unnecessary and
+ * undesirable to call this function first.
+ *
+ * Read the config file, find scanners with help from sanei_*
+ * store in global device structs
+ */
+SANE_Status
+sane_get_devices (const SANE_Device *** device_list, SANE_Bool local_only)
+{
+ struct scanner *dev;
+ char line[PATH_MAX];
+ const char *lp;
+ FILE *fp;
+ int num_devices=0;
+ int i=0;
+
+ local_only = local_only; /* get rid of compiler warning */
+
+ DBG (10, "sane_get_devices: start\n");
+
+ global_has_cal_buffer = 1;
+ global_lines_per_block = 16;
+
+ fp = sanei_config_open (CONFIG_FILE);
+
+ if (fp) {
+
+ DBG (15, "sane_get_devices: reading config file %s\n", CONFIG_FILE);
+
+ while (sanei_config_read (line, PATH_MAX, fp)) {
+
+ lp = line;
+
+ /* ignore comments */
+ if (*lp == '#')
+ continue;
+
+ /* skip empty lines */
+ if (*lp == 0)
+ continue;
+
+ if ((strncmp ("usb", lp, 3) == 0) && isspace (lp[3])) {
+ DBG (15, "sane_get_devices: looking for '%s'\n", lp);
+ sanei_usb_attach_matching_devices(lp, attach_one);
+ }
+
+ else if (!strncmp(lp, "has_cal_buffer", 14) && isspace (lp[14])) {
+
+ int buf;
+ lp += 14;
+ lp = sanei_config_skip_whitespace (lp);
+ buf = atoi (lp);
+
+ if(buf){
+ global_has_cal_buffer = 1;
+ }
+ else{
+ global_has_cal_buffer = 0;
+ }
+
+ DBG (15, "sane_get_devices: setting \"has_cal_buffer\" to %d\n",
+ global_has_cal_buffer);
+ }
+
+ else if (!strncmp(lp, "lines_per_block", 15) && isspace (lp[15])) {
+
+ int buf;
+ lp += 15;
+ lp = sanei_config_skip_whitespace (lp);
+ buf = atoi (lp);
+
+ if(buf < 1 || buf > 32){
+ DBG (15,
+ "sane_get_devices: \"lines_per_block\"=%d\n out of range",
+ buf
+ );
+ continue;
+ }
+
+ DBG (15, "sane_get_devices: \"lines_per_block\" is %d\n", buf);
+ global_lines_per_block = buf;
+ }
+
+ else{
+ DBG (5, "sane_get_devices: config line \"%s\" ignored.\n", lp);
+ }
+ }
+ fclose (fp);
+ }
+
+ else {
+ DBG (5, "sane_get_devices: no config file '%s', using defaults\n",
+ CONFIG_FILE);
+
+ DBG (15, "sane_get_devices: looking for 'usb 0x08F0 0x0005'\n");
+ sanei_usb_attach_matching_devices("usb 0x08F0 0x0005", attach_one);
+ }
+
+ for (dev = scanner_devList; dev; dev=dev->next) {
+ DBG (15, "sane_get_devices: found scanner %s\n",dev->device_name);
+ num_devices++;
+ }
+
+ DBG (15, "sane_get_devices: found %d scanner(s)\n",num_devices);
+
+ sane_devArray = calloc (num_devices + 1, sizeof (SANE_Device*));
+ if (!sane_devArray)
+ return SANE_STATUS_NO_MEM;
+
+ for (dev = scanner_devList; dev; dev=dev->next) {
+ sane_devArray[i++] = (SANE_Device *)&dev->sane;
+ }
+
+ sane_devArray[i] = 0;
+
+ *device_list = sane_devArray;
+
+ DBG (10, "sane_get_devices: finish\n");
+
+ return SANE_STATUS_GOOD;
+}
+
+/* callback used by sane_get_devices
+ * build the scanner struct and link to global list
+ * unless struct is already loaded, then pretend
+ */
+static SANE_Status
+attach_one (const char *device_name)
+{
+ struct scanner *s;
+ int ret, i;
+ SANE_Word vid, pid;
+
+ DBG (10, "attach_one: start '%s'\n", device_name);
+
+ for (s = scanner_devList; s; s = s->next) {
+ if (strcmp (s->sane.name, device_name) == 0) {
+ DBG (10, "attach_one: already attached!\n");
+ return SANE_STATUS_GOOD;
+ }
+ }
+
+ /* build a scanner struct to hold it */
+ DBG (15, "attach_one: init struct\n");
+
+ if ((s = calloc (sizeof (*s), 1)) == NULL)
+ return SANE_STATUS_NO_MEM;
+
+ /* copy the device name */
+ s->device_name = strdup (device_name);
+ if (!s->device_name){
+ free (s);
+ return SANE_STATUS_NO_MEM;
+ }
+
+ /* connect the fd */
+ DBG (15, "attach_one: connect fd\n");
+
+ s->fd = -1;
+ ret = connect_fd(s);
+ if(ret != SANE_STATUS_GOOD){
+ free (s->device_name);
+ free (s);
+ return ret;
+ }
+
+ /* clean up the scanner struct based on model */
+ /* this is the only piece of model specific code */
+ sanei_usb_get_vendor_product(s->fd,&vid,&pid);
+
+ if(vid == 0x08f0){
+ s->vendor_name = "CardScan";
+ if(pid == 0x0005){
+ s->product_name = "800c";
+ }
+ else if(pid == 0x0002){
+ s->product_name = "600c";
+ }
+ else{
+ DBG (5, "Unknown product, using default settings\n");
+ s->product_name = "Unknown";
+ }
+ }
+ else{
+ DBG (5, "Unknown vendor/product, using default settings\n");
+ s->vendor_name = "Unknown";
+ s->product_name = "Unknown";
+ }
+
+ DBG (15, "attach_one: Found %s scanner %s at %s\n",
+ s->vendor_name, s->product_name, s->device_name);
+
+ /*copy config file settings*/
+ s->has_cal_buffer = global_has_cal_buffer;
+ s->lines_per_block = global_lines_per_block;
+ s->color_block_size = s->lines_per_block * PIXELS_PER_LINE * 3;
+ s->gray_block_size = s->lines_per_block * PIXELS_PER_LINE;
+
+ /* try to get calibration */
+ if(s->has_cal_buffer){
+ DBG (15, "attach_one: scanner calibration\n");
+
+ ret = load_calibration(s);
+ if (ret != SANE_STATUS_GOOD) {
+ DBG (5, "sane_start: ERROR: cannot calibrate, incompatible?\n");
+ free (s->device_name);
+ free (s);
+ return ret;
+ }
+ }
+ else{
+ DBG (15, "attach_one: skipping calibration\n");
+ }
+
+ /* set SANE option 'values' to good defaults */
+ DBG (15, "attach_one: init options\n");
+
+ /* go ahead and setup the first opt, because
+ * frontend may call control_option on it
+ * before calling get_option_descriptor
+ */
+ memset (s->opt, 0, sizeof (s->opt));
+ for (i = 0; i < NUM_OPTIONS; ++i) {
+ s->opt[i].name = "filler";
+ s->opt[i].size = sizeof (SANE_Word);
+ s->opt[i].cap = SANE_CAP_INACTIVE;
+ }
+
+ s->opt[OPT_NUM_OPTS].name = SANE_NAME_NUM_OPTIONS;
+ s->opt[OPT_NUM_OPTS].title = SANE_TITLE_NUM_OPTIONS;
+ s->opt[OPT_NUM_OPTS].desc = SANE_DESC_NUM_OPTIONS;
+ s->opt[OPT_NUM_OPTS].type = SANE_TYPE_INT;
+ s->opt[OPT_NUM_OPTS].cap = SANE_CAP_SOFT_DETECT;
+
+ DBG (15, "attach_one: init settings\n");
+
+ /* we close the connection, so that another backend can talk to scanner */
+ disconnect_fd(s);
+
+ /* load info into sane_device struct */
+ s->sane.name = s->device_name;
+ s->sane.vendor = s->vendor_name;
+ s->sane.model = s->product_name;
+ s->sane.type = "scanner";
+
+ s->next = scanner_devList;
+ scanner_devList = s;
+
+ DBG (10, "attach_one: finish\n");
+
+ return SANE_STATUS_GOOD;
+}
+
+/*
+ * connect the fd in the scanner struct
+ */
+static SANE_Status
+connect_fd (struct scanner *s)
+{
+ SANE_Status ret;
+
+ DBG (10, "connect_fd: start\n");
+
+ if(s->fd > -1){
+ DBG (5, "connect_fd: already open\n");
+ ret = SANE_STATUS_GOOD;
+ }
+ else {
+ DBG (15, "connect_fd: opening USB device\n");
+ ret = sanei_usb_open (s->device_name, &(s->fd));
+ }
+
+ if(ret != SANE_STATUS_GOOD){
+ DBG (5, "connect_fd: could not open device: %d\n", ret);
+ }
+
+ DBG (10, "connect_fd: finish\n");
+
+ return ret;
+}
+
+static SANE_Status
+load_calibration(struct scanner *s)
+{
+ SANE_Status ret=SANE_STATUS_GOOD;
+ unsigned char cmd[] = {0x45, 0x00, 0x00};
+ unsigned char * buf;
+ size_t bytes = HEADER_SIZE + CAL_COLOR_SIZE*2 + CAL_GRAY_SIZE*2;
+ int j;
+
+ DBG (10, "load_calibration: start\n");
+
+ buf = malloc(bytes);
+ if(!buf){
+ DBG(5, "load_calibration: not enough mem for buffer: %ld\n",(long)bytes);
+ return SANE_STATUS_NO_MEM;
+ }
+
+ ret = do_cmd(
+ s, 0,
+ cmd, sizeof(cmd),
+ NULL, 0,
+ buf, &bytes
+ );
+
+ if (ret == SANE_STATUS_GOOD) {
+ DBG(15, "load_calibration: got GOOD\n");
+
+ /*
+ * color cal data comes from scaner like:
+ * bbbbbbbBBBBBBBgggggggGGGGGGGrrrrrrrRRRRRRR
+ * where b=darkblue, B=lightblue, etc
+ * reorder the data into two buffers
+ * bbbbbbbgggggggrrrrrrr and BBBBBBBGGGGGGGRRRRRRR
+ */
+
+ /*dark/light blue*/
+ memcpy(s->cal_color_b, buf+HEADER_SIZE, PIXELS_PER_LINE);
+ memcpy(s->cal_color_w,
+ buf+HEADER_SIZE+PIXELS_PER_LINE, PIXELS_PER_LINE);
+
+ /*dark/light green*/
+ memcpy(s->cal_color_b+PIXELS_PER_LINE,
+ buf+HEADER_SIZE+(PIXELS_PER_LINE*2), PIXELS_PER_LINE);
+ memcpy(s->cal_color_w+PIXELS_PER_LINE,
+ buf+HEADER_SIZE+(PIXELS_PER_LINE*3), PIXELS_PER_LINE);
+
+ /*dark/light red*/
+ memcpy(s->cal_color_b+(PIXELS_PER_LINE*2),
+ buf+HEADER_SIZE+(PIXELS_PER_LINE*4), PIXELS_PER_LINE);
+ memcpy(s->cal_color_w+(PIXELS_PER_LINE*2),
+ buf+HEADER_SIZE+(PIXELS_PER_LINE*5), PIXELS_PER_LINE);
+
+ /* then slide the light data down using the dark offset */
+ for(j=0;j<CAL_COLOR_SIZE;j++){
+ s->cal_color_w[j] -= s->cal_color_b[j];
+ }
+
+ /*dark/light gray*/
+ memcpy(s->cal_gray_b,
+ buf+HEADER_SIZE+(CAL_COLOR_SIZE*2), PIXELS_PER_LINE);
+ memcpy(s->cal_gray_w,
+ buf+HEADER_SIZE+(CAL_COLOR_SIZE*2)+PIXELS_PER_LINE, PIXELS_PER_LINE);
+
+ /* then slide the light data down using the dark offset */
+ for(j=0;j<CAL_GRAY_SIZE;j++){
+ s->cal_gray_w[j] -= s->cal_gray_b[j];
+ }
+
+ hexdump(35, "cal_color_b:", s->cal_color_b, CAL_COLOR_SIZE);
+ hexdump(35, "cal_color_w:", s->cal_color_w, CAL_COLOR_SIZE);
+ hexdump(35, "cal_gray_b:", s->cal_gray_b, CAL_GRAY_SIZE);
+ hexdump(35, "cal_gray_w:", s->cal_gray_w, CAL_GRAY_SIZE);
+ }
+ else {
+ DBG(5, "load_calibration: error reading data block status = %d\n", ret);
+ }
+
+ DBG (10, "load_calibration: finish\n");
+
+ return ret;
+}
+
+/*
+ * From the SANE spec:
+ * This function is used to establish a connection to a particular
+ * device. The name of the device to be opened is passed in argument
+ * name. If the call completes successfully, a handle for the device
+ * is returned in *h. As a special case, specifying a zero-length
+ * string as the device requests opening the first available device
+ * (if there is such a device).
+ */
+SANE_Status
+sane_open (SANE_String_Const name, SANE_Handle * handle)
+{
+ struct scanner *dev = NULL;
+ struct scanner *s = NULL;
+ SANE_Status ret;
+
+ DBG (10, "sane_open: start\n");
+
+ if(name[0] == 0){
+ if(scanner_devList){
+ DBG (15, "sane_open: no device requested, using first\n");
+ s = scanner_devList;
+ }
+ else{
+ DBG (15, "sane_open: no device requested, none found\n");
+ }
+ }
+ else{
+ DBG (15, "sane_open: device %s requested, attaching\n", name);
+
+ ret = attach_one(name);
+ if(ret){
+ DBG (5, "sane_open: attach error %d\n",ret);
+ return ret;
+ }
+
+ for (dev = scanner_devList; dev; dev = dev->next) {
+ if (strcmp (dev->sane.name, name) == 0) {
+ s = dev;
+ break;
+ }
+ }
+ }
+
+ if (!s) {
+ DBG (5, "sane_open: no device found\n");
+ return SANE_STATUS_INVAL;
+ }
+
+ DBG (15, "sane_open: device %s found\n", s->sane.name);
+
+ *handle = s;
+
+ /* connect the fd so we can talk to scanner */
+ ret = connect_fd(s);
+ if(ret != SANE_STATUS_GOOD){
+ return ret;
+ }
+
+ DBG (10, "sane_open: finish\n");
+
+ return SANE_STATUS_GOOD;
+}
+
+/*
+ * @@ Section 3 - SANE Options functions
+ */
+
+/*
+ * Returns the options we know.
+ *
+ * From the SANE spec:
+ * This function is used to access option descriptors. The function
+ * returns the option descriptor for option number n of the device
+ * represented by handle h. Option number 0 is guaranteed to be a
+ * valid option. Its value is an integer that specifies the number of
+ * options that are available for device handle h (the count includes
+ * option 0). If n is not a valid option index, the function returns
+ * NULL. The returned option descriptor is guaranteed to remain valid
+ * (and at the returned address) until the device is closed.
+ */
+const SANE_Option_Descriptor *
+sane_get_option_descriptor (SANE_Handle handle, SANE_Int option)
+{
+ struct scanner *s = handle;
+ int i;
+ SANE_Option_Descriptor *opt = &s->opt[option];
+
+ DBG (20, "sane_get_option_descriptor: %d\n", option);
+
+ if ((unsigned) option >= NUM_OPTIONS)
+ return NULL;
+
+ /* "Mode" group -------------------------------------------------------- */
+ if(option==OPT_MODE_GROUP){
+ opt->title = "Scan Mode";
+ opt->desc = "";
+ opt->type = SANE_TYPE_GROUP;
+ opt->constraint_type = SANE_CONSTRAINT_NONE;
+ }
+
+ /* scan mode */
+ else if(option==OPT_MODE){
+ i=0;
+ s->mode_list[i++]=STRING_GRAYSCALE;
+ s->mode_list[i++]=STRING_COLOR;
+ s->mode_list[i]=NULL;
+
+ opt->name = SANE_NAME_SCAN_MODE;
+ opt->title = SANE_TITLE_SCAN_MODE;
+ opt->desc = SANE_DESC_SCAN_MODE;
+ opt->type = SANE_TYPE_STRING;
+ opt->constraint_type = SANE_CONSTRAINT_STRING_LIST;
+ opt->constraint.string_list = s->mode_list;
+ opt->size = maxStringSize (opt->constraint.string_list);
+ opt->cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
+ }
+
+ return opt;
+}
+
+/**
+ * Gets or sets an option value.
+ *
+ * From the SANE spec:
+ * This function is used to set or inquire the current value of option
+ * number n of the device represented by handle h. The manner in which
+ * the option is controlled is specified by parameter action. The
+ * possible values of this parameter are described in more detail
+ * below. The value of the option is passed through argument val. It
+ * is a pointer to the memory that holds the option value. The memory
+ * area pointed to by v must be big enough to hold the entire option
+ * value (determined by member size in the corresponding option
+ * descriptor).
+ *
+ * The only exception to this rule is that when setting the value of a
+ * string option, the string pointed to by argument v may be shorter
+ * since the backend will stop reading the option value upon
+ * encountering the first NUL terminator in the string. If argument i
+ * is not NULL, the value of *i will be set to provide details on how
+ * well the request has been met.
+ */
+SANE_Status
+sane_control_option (SANE_Handle handle, SANE_Int option,
+ SANE_Action action, void *val, SANE_Int * info)
+{
+ struct scanner *s = (struct scanner *) handle;
+ SANE_Int dummy = 0;
+
+ /* Make sure that all those statements involving *info cannot break (better
+ * than having to do "if (info) ..." everywhere!)
+ */
+ if (info == 0)
+ info = &dummy;
+
+ if (option >= NUM_OPTIONS) {
+ DBG (5, "sane_control_option: %d too big\n", option);
+ return SANE_STATUS_INVAL;
+ }
+
+ if (!SANE_OPTION_IS_ACTIVE (s->opt[option].cap)) {
+ DBG (5, "sane_control_option: %d inactive\n", option);
+ return SANE_STATUS_INVAL;
+ }
+
+ /*
+ * SANE_ACTION_GET_VALUE: We have to find out the current setting and
+ * return it in a human-readable form (often, text).
+ */
+ if (action == SANE_ACTION_GET_VALUE) {
+ SANE_Word * val_p = (SANE_Word *) val;
+
+ DBG (20, "sane_control_option: get value for '%s' (%d)\n", s->opt[option].name,option);
+
+ switch (option) {
+
+ case OPT_NUM_OPTS:
+ *val_p = NUM_OPTIONS;
+ return SANE_STATUS_GOOD;
+
+ case OPT_MODE:
+ if(s->mode == MODE_GRAYSCALE){
+ strcpy (val, STRING_GRAYSCALE);
+ }
+ else if(s->mode == MODE_COLOR){
+ strcpy (val, STRING_COLOR);
+ }
+ return SANE_STATUS_GOOD;
+ }
+ }
+ else if (action == SANE_ACTION_SET_VALUE) {
+ int tmp;
+ SANE_Word val_c;
+ SANE_Status status;
+
+ DBG (20, "sane_control_option: set value for '%s' (%d)\n", s->opt[option].name,option);
+
+ if ( s->started ) {
+ DBG (5, "sane_control_option: cant set, device busy\n");
+ return SANE_STATUS_DEVICE_BUSY;
+ }
+
+ if (!SANE_OPTION_IS_SETTABLE (s->opt[option].cap)) {
+ DBG (5, "sane_control_option: not settable\n");
+ return SANE_STATUS_INVAL;
+ }
+
+ status = sanei_constrain_value (s->opt + option, val, info);
+ if (status != SANE_STATUS_GOOD) {
+ DBG (5, "sane_control_option: bad value\n");
+ return status;
+ }
+
+ /* may have been changed by constrain, so dont copy until now */
+ val_c = *(SANE_Word *)val;
+
+ /*
+ * Note - for those options which can assume one of a list of
+ * valid values, we can safely assume that they will have
+ * exactly one of those values because that's what
+ * sanei_constrain_value does. Hence no "else: invalid" branches
+ * below.
+ */
+ switch (option) {
+
+ /* Mode Group */
+ case OPT_MODE:
+ if (!strcmp (val, STRING_GRAYSCALE)) {
+ tmp = MODE_GRAYSCALE;
+ }
+ else{
+ tmp = MODE_COLOR;
+ }
+
+ if (tmp == s->mode)
+ return SANE_STATUS_GOOD;
+
+ s->mode = tmp;
+ *info |= SANE_INFO_RELOAD_PARAMS | SANE_INFO_RELOAD_OPTIONS;
+ return SANE_STATUS_GOOD;
+
+ } /* switch */
+ } /* else */
+
+ return SANE_STATUS_INVAL;
+}
+
+/*
+ * @@ Section 4 - SANE scanning functions
+ */
+/*
+ * Called by SANE to retrieve information about the type of data
+ * that the current scan will return.
+ *
+ * From the SANE spec:
+ * This function is used to obtain the current scan parameters. The
+ * returned parameters are guaranteed to be accurate between the time
+ * a scan has been started (sane_start() has been called) and the
+ * completion of that request. Outside of that window, the returned
+ * values are best-effort estimates of what the parameters will be
+ * when sane_start() gets invoked.
+ *
+ * Calling this function before a scan has actually started allows,
+ * for example, to get an estimate of how big the scanned image will
+ * be. The parameters passed to this function are the handle h of the
+ * device for which the parameters should be obtained and a pointer p
+ * to a parameter structure.
+ */
+SANE_Status
+sane_get_parameters (SANE_Handle handle, SANE_Parameters * params)
+{
+ struct scanner *s = (struct scanner *) handle;
+
+ DBG (10, "sane_get_parameters: start\n");
+
+ params->pixels_per_line = PIXELS_PER_LINE;
+ params->lines = -1;
+ params->last_frame = 1;
+
+ if (s->mode == MODE_COLOR) {
+ params->format = SANE_FRAME_RGB;
+ params->depth = 8;
+ params->bytes_per_line = params->pixels_per_line * 3;
+ }
+ else if (s->mode == MODE_GRAYSCALE) {
+ params->format = SANE_FRAME_GRAY;
+ params->depth = 8;
+ params->bytes_per_line = params->pixels_per_line;
+ }
+
+ DBG (15, "\tdepth %d\n", params->depth);
+ DBG (15, "\tlines %d\n", params->lines);
+ DBG (15, "\tpixels_per_line %d\n", params->pixels_per_line);
+ DBG (15, "\tbytes_per_line %d\n", params->bytes_per_line);
+
+ DBG (10, "sane_get_parameters: finish\n");
+
+ return SANE_STATUS_GOOD;
+}
+
+/*
+ * Called by SANE when a page acquisition operation is to be started.
+ */
+SANE_Status
+sane_start (SANE_Handle handle)
+{
+ struct scanner *s = handle;
+ SANE_Status ret;
+
+ DBG (10, "sane_start: start\n");
+
+ /* first page of batch */
+ if(s->started){
+ DBG(5,"sane_start: previous transfer not finished?");
+ sane_cancel((SANE_Handle)s);
+ return SANE_STATUS_CANCELLED;
+ }
+
+ /* set clean defaults */
+ s->started=1;
+ s->bytes_rx=0;
+ s->bytes_tx=0;
+ s->paperless_lines=0;
+
+ /* heat up the lamp */
+ if(s->mode == MODE_COLOR){
+ ret = heat_lamp_color(s);
+ }
+ else{
+ ret = heat_lamp_gray(s);
+ }
+
+ if (ret != SANE_STATUS_GOOD) {
+ DBG (5, "sane_start: ERROR: failed to heat lamp\n");
+ sane_cancel((SANE_Handle)s);
+ return ret;
+ }
+
+ DBG (10, "sane_start: finish\n");
+
+ return SANE_STATUS_GOOD;
+}
+
+static SANE_Status
+heat_lamp_gray(struct scanner *s)
+{
+ SANE_Status ret = SANE_STATUS_GOOD;
+ SANE_Status ret2 = SANE_STATUS_GOOD;
+ unsigned char cmd[] =
+ {0x12, 0x06, 0x00, 0x00, 0x01, 0x60, 0x00, 0x61, 0x00};
+ size_t bytes = HEADER_SIZE + 1;
+ unsigned char * buf;
+ int i;
+
+ DBG (10, "heat_lamp_gray: start\n");
+
+ buf = malloc(bytes);
+ if(!buf){
+ DBG(5, "heat_lamp_gray: not enough mem for buffer: %lu\n",
+ (long unsigned)bytes);
+ return SANE_STATUS_NO_MEM;
+ }
+
+ for(i=0;i<10;i++){
+
+ ret2 = do_cmd(
+ s, 0,
+ cmd, sizeof(cmd),
+ NULL, 0,
+ buf, &bytes
+ );
+
+ if (ret2 != SANE_STATUS_GOOD) {
+ DBG(5, "heat_lamp_gray: %d error\n",i);
+ ret = ret2;
+ break;
+ }
+
+ if(!buf[1]){
+ DBG(5, "heat_lamp_gray: %d got no docs\n",i);
+ ret = SANE_STATUS_NO_DOCS;
+ break;
+ }
+
+ DBG(15, "heat_lamp_gray: %d got: %d %d\n",i,
+ buf[HEADER_SIZE],s->cal_gray_b[0]);
+
+ if(buf[HEADER_SIZE] < 0x20){
+ DBG(15, "heat_lamp_gray: hot\n");
+ ret = SANE_STATUS_GOOD;
+ break;
+ }
+ else{
+ DBG(15, "heat_lamp_gray: cold\n");
+ ret = SANE_STATUS_DEVICE_BUSY;
+ }
+ }
+
+ free(buf);
+
+ DBG (10, "heat_lamp_gray: finish %d\n",ret);
+
+ return ret;
+}
+
+static SANE_Status
+heat_lamp_color(struct scanner *s)
+{
+ SANE_Status ret = SANE_STATUS_GOOD;
+ SANE_Status ret2 = SANE_STATUS_GOOD;
+ unsigned char cmd[] =
+ {0x18, 0x07, 0x00, 0x00, 0x01, 0x60, 0x00, 0x61, 0x00, 0x07};
+ size_t bytes = HEADER_SIZE + 3;
+ unsigned char * buf;
+ int i;
+
+ DBG (10, "heat_lamp_color: start\n");
+
+ buf = malloc(bytes);
+ if(!buf){
+ DBG(5, "heat_lamp_color: not enough mem for buffer: %lu\n",
+ (long unsigned)bytes);
+ return SANE_STATUS_NO_MEM;
+ }
+
+ for(i=0;i<10;i++){
+
+ ret2 = do_cmd(
+ s, 0,
+ cmd, sizeof(cmd),
+ NULL, 0,
+ buf, &bytes
+ );
+
+ if (ret2 != SANE_STATUS_GOOD) {
+ DBG(5, "heat_lamp_color: %d error\n",i);
+ ret = ret2;
+ break;
+ }
+
+ if(!buf[1]){
+ DBG(5, "heat_lamp_color: %d got no docs\n",i);
+ ret = SANE_STATUS_NO_DOCS;
+ break;
+ }
+
+ DBG(15, "heat_lamp_color: %d got: %d,%d,%d %d,%d,%d\n",i,
+ buf[HEADER_SIZE],buf[HEADER_SIZE+1],buf[HEADER_SIZE+2],
+ s->cal_color_b[0],s->cal_color_b[1],s->cal_color_b[2]);
+
+ if(buf[HEADER_SIZE] < 0x20
+ && buf[HEADER_SIZE+1] < 0x20
+ && buf[HEADER_SIZE+2] < 0x20){
+ DBG(15, "heat_lamp_color: hot\n");
+ ret = SANE_STATUS_GOOD;
+ break;
+ }
+ else{
+ DBG(15, "heat_lamp_color: cold\n");
+ ret = SANE_STATUS_DEVICE_BUSY;
+ }
+ }
+
+ free(buf);
+
+ DBG (10, "heat_lamp_color: finish %d\n",ret);
+
+ return ret;
+}
+
+/*
+ * Called by SANE to read data.
+ *
+ * From the SANE spec:
+ * This function is used to read image data from the device
+ * represented by handle h. Argument buf is a pointer to a memory
+ * area that is at least maxlen bytes long. The number of bytes
+ * returned is stored in *len. A backend must set this to zero when
+ * the call fails (i.e., when a status other than SANE_STATUS_GOOD is
+ * returned).
+ *
+ * When the call succeeds, the number of bytes returned can be
+ * anywhere in the range from 0 to maxlen bytes.
+ */
+SANE_Status
+sane_read (SANE_Handle handle, SANE_Byte * buf, SANE_Int max_len, SANE_Int * len)
+{
+ struct scanner *s = (struct scanner *) handle;
+ SANE_Status ret=SANE_STATUS_GOOD;
+
+ DBG (10, "sane_read: start\n");
+
+ *len = 0;
+
+ /* cancelled? */
+ if(!s->started){
+ DBG (5, "sane_read: call sane_start first\n");
+ return SANE_STATUS_CANCELLED;
+ }
+
+ /* have sent all of current buffer */
+ if(s->bytes_tx == s->bytes_rx){
+
+ /* at end of data, stop */
+ if(s->paperless_lines >= MAX_PAPERLESS_LINES){
+ DBG (15, "sane_read: returning eof\n");
+ power_down(s);
+ return SANE_STATUS_EOF;
+ }
+
+ /* more to get, reset and go */
+ s->bytes_tx = 0;
+ s->bytes_rx = 0;
+
+ if(s->mode == MODE_COLOR){
+ ret = read_from_scanner_color(s);
+ }
+ else{
+ ret = read_from_scanner_gray(s);
+ }
+
+ if(ret){
+ DBG(5,"sane_read: returning %d\n",ret);
+ return ret;
+ }
+ }
+
+ /* data in current buffer, send some of it */
+ *len = s->bytes_rx - s->bytes_tx;
+ if(*len > max_len){
+ *len = max_len;
+ }
+
+ memcpy(buf,s->buffer+s->bytes_tx,*len);
+ s->bytes_tx += *len;
+
+ DBG (10, "sane_read: %d,%d,%d finish\n", *len,s->bytes_rx,s->bytes_tx);
+
+ return ret;
+}
+
+static SANE_Status
+read_from_scanner_gray(struct scanner *s)
+{
+ SANE_Status ret=SANE_STATUS_GOOD;
+ /*cmd len-le16 move lines ??? ??? ??? ???*/
+ unsigned char cmd[] =
+ {0x12, 0x06, 0x00, 0x01, 0x01, 0x60, 0x00, 0x18, 0x05};
+ size_t bytes = HEADER_SIZE + s->gray_block_size;
+ unsigned char * buf;
+ int i,j;
+
+ DBG (10, "read_from_scanner_gray: start\n");
+
+ cmd[4] = s->lines_per_block;
+
+ buf = malloc(bytes);
+ if(!buf){
+ DBG(5, "read_from_scanner_gray: not enough mem for buffer: %lu\n",
+ (long unsigned)bytes);
+ return SANE_STATUS_NO_MEM;
+ }
+
+ ret = do_cmd(
+ s, 0,
+ cmd, sizeof(cmd),
+ NULL, 0,
+ buf, &bytes
+ );
+
+ if (ret == SANE_STATUS_GOOD) {
+
+ DBG(15, "read_from_scanner_gray: got GOOD\n");
+
+ if(!buf[1]){
+ s->paperless_lines += s->lines_per_block;
+ }
+
+ s->bytes_rx = s->gray_block_size;
+
+ /*memcpy(s->buffer,buf+HEADER_SIZE,s->gray_block_size);*/
+
+ /* reorder the gray data into the struct's buffer */
+ for(i=0;i<s->gray_block_size;i+=PIXELS_PER_LINE){
+ for(j=0;j<PIXELS_PER_LINE;j++){
+
+ unsigned char byte = buf[ HEADER_SIZE + i + j ];
+ unsigned char bcal = s->cal_gray_b[j];
+ unsigned char wcal = s->cal_gray_w[j];
+
+ byte = (byte <= bcal)?0:(byte-bcal);
+ byte = (byte >= wcal)?255:(byte*255/wcal);
+ s->buffer[i+j] = byte;
+ }
+ }
+ }
+ else {
+ DBG(5, "read_from_scanner_gray: error reading status = %d\n", ret);
+ }
+
+ free(buf);
+
+ DBG (10, "read_from_scanner_gray: finish\n");
+
+ return ret;
+}
+
+static SANE_Status
+read_from_scanner_color(struct scanner *s)
+{
+ SANE_Status ret=SANE_STATUS_GOOD;
+ unsigned char cmd[] =
+ {0x18, 0x07, 0x00, 0x01, 0x01, 0x60, 0x00, 0x18, 0x05, 0x07};
+ size_t bytes = HEADER_SIZE + s->color_block_size;
+ unsigned char * buf;
+ int i,j,k;
+
+ DBG (10, "read_from_scanner_color: start\n");
+
+ cmd[4] = s->lines_per_block;
+
+ buf = malloc(bytes);
+ if(!buf){
+ DBG(5, "read_from_scanner_color: not enough mem for buffer: %lu\n",
+ (long unsigned)bytes);
+ return SANE_STATUS_NO_MEM;
+ }
+
+ ret = do_cmd(
+ s, 0,
+ cmd, sizeof(cmd),
+ NULL, 0,
+ buf, &bytes
+ );
+
+ if (ret == SANE_STATUS_GOOD) {
+
+ DBG(15, "read_from_scanner_color: got GOOD\n");
+
+ if(!buf[1]){
+ s->paperless_lines += s->lines_per_block;
+ }
+
+ s->bytes_rx = s->color_block_size;
+
+ /*memcpy(s->buffer,buf+HEADER_SIZE,s->color_block_size);*/
+
+ /* reorder the color data into the struct's buffer */
+ for(i=0;i<s->color_block_size;i+=PIXELS_PER_LINE*3){
+ for(j=0;j<PIXELS_PER_LINE;j++){
+ for(k=0;k<3;k++){
+
+ int offset = PIXELS_PER_LINE*(2-k) + j;
+ unsigned char byte = buf[ HEADER_SIZE + i + offset ];
+ unsigned char bcal = s->cal_color_b[offset];
+ unsigned char wcal = s->cal_color_w[offset];
+
+ byte = (byte <= bcal)?0:(byte-bcal);
+ byte = (byte >= wcal)?255:(byte*255/wcal);
+ s->buffer[i+j*3+k] = byte;
+ }
+ }
+ }
+ }
+ else {
+ DBG(5, "read_from_scanner_color: error reading status = %d\n", ret);
+ }
+
+ free(buf);
+
+ DBG (10, "read_from_scanner_color: finish\n");
+
+ return ret;
+}
+
+/*
+ * @@ Section 4 - SANE cleanup functions
+ */
+/*
+ * Cancels a scan.
+ *
+ * From the SANE spec:
+ * This function is used to immediately or as quickly as possible
+ * cancel the currently pending operation of the device represented by
+ * handle h. This function can be called at any time (as long as
+ * handle h is a valid handle) but usually affects long-running
+ * operations only (such as image is acquisition). It is safe to call
+ * this function asynchronously (e.g., from within a signal handler).
+ * It is important to note that completion of this operaton does not
+ * imply that the currently pending operation has been cancelled. It
+ * only guarantees that cancellation has been initiated. Cancellation
+ * completes only when the cancelled call returns (typically with a
+ * status value of SANE_STATUS_CANCELLED). Since the SANE API does
+ * not require any other operations to be re-entrant, this implies
+ * that a frontend must not call any other operation until the
+ * cancelled operation has returned.
+ */
+void
+sane_cancel (SANE_Handle handle)
+{
+ struct scanner * s = (struct scanner *) handle;
+ DBG (10, "sane_cancel: start\n");
+ s->started = 0;
+ DBG (10, "sane_cancel: finish\n");
+}
+
+static SANE_Status
+power_down(struct scanner *s)
+{
+ SANE_Status ret = SANE_STATUS_GOOD;
+
+ unsigned char cmd[] = {0x21, 0x02, 0x00, 0x0a, 0x00};
+ unsigned char buf[6];
+ size_t bytes = sizeof(buf);
+ int i;
+
+ DBG (10, "power_down: start\n");
+
+ for(i=0;i<5;i++){
+ ret = do_cmd(
+ s, 0,
+ cmd, sizeof(cmd),
+ NULL, 0,
+ buf, &bytes
+ );
+
+ if(ret != SANE_STATUS_GOOD){
+ break;
+ }
+ }
+
+#if 0
+ unsigned char cmd[] = {0x35, 0x01, 0x00, 0xff};
+ unsigned char buf[5];
+ size_t bytes = sizeof(buf);
+
+ DBG (10, "power_down: start\n");
+
+ ret = do_cmd(
+ s, 0,
+ cmd, sizeof(cmd),
+ NULL, 0,
+ buf, &bytes
+ );
+#endif
+
+ DBG (10, "power_down: finish %d\n",ret);
+
+ return ret;
+}
+
+/*
+ * Ends use of the scanner.
+ *
+ * From the SANE spec:
+ * This function terminates the association between the device handle
+ * passed in argument h and the device it represents. If the device is
+ * presently active, a call to sane_cancel() is performed first. After
+ * this function returns, handle h must not be used anymore.
+ */
+void
+sane_close (SANE_Handle handle)
+{
+ DBG (10, "sane_close: start\n");
+
+ sane_cancel(handle);
+ disconnect_fd((struct scanner *) handle);
+
+ DBG (10, "sane_close: finish\n");
+}
+
+static SANE_Status
+disconnect_fd (struct scanner *s)
+{
+ DBG (10, "disconnect_fd: start\n");
+
+ if(s->fd > -1){
+ DBG (15, "disconnecting usb device\n");
+ sanei_usb_close (s->fd);
+ s->fd = -1;
+ }
+
+ DBG (10, "disconnect_fd: finish\n");
+
+ return SANE_STATUS_GOOD;
+}
+
+/*
+ * Terminates the backend.
+ *
+ * From the SANE spec:
+ * This function must be called to terminate use of a backend. The
+ * function will first close all device handles that still might be
+ * open (it is recommended to close device handles explicitly through
+ * a call to sane_close(), but backends are required to release all
+ * resources upon a call to this function). After this function
+ * returns, no function other than sane_init() may be called
+ * (regardless of the status value returned by sane_exit(). Neglecting
+ * to call this function may result in some resources not being
+ * released properly.
+ */
+void
+sane_exit (void)
+{
+ struct scanner *dev, *next;
+
+ DBG (10, "sane_exit: start\n");
+
+ for (dev = scanner_devList; dev; dev = next) {
+ disconnect_fd(dev);
+ next = dev->next;
+ free (dev->device_name);
+ free (dev);
+ }
+
+ if (sane_devArray)
+ free (sane_devArray);
+
+ scanner_devList = NULL;
+ sane_devArray = NULL;
+
+ DBG (10, "sane_exit: finish\n");
+}
+
+
+/*
+ * @@ Section 5 - misc helper functions
+ */
+/*
+ * 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;
+}
+
+/**
+ * Convenience method to determine longest string size in a list.
+ */
+static size_t
+maxStringSize (const SANE_String_Const strings[])
+{
+ size_t size, max_size = 0;
+ int i;
+
+ for (i = 0; strings[i]; ++i) {
+ size = strlen (strings[i]) + 1;
+ if (size > max_size)
+ max_size = size;
+ }
+
+ return max_size;
+}
+
+/**
+ * Prints a hex dump of the given buffer onto the debug output stream.
+ */
+static void
+hexdump (int level, char *comment, unsigned char *p, int l)
+{
+ int i;
+ char line[128];
+ char *ptr;
+
+ if(DBG_LEVEL < level)
+ return;
+
+ DBG (level, "%s\n", comment);
+ ptr = line;
+ for (i = 0; i < l; i++, p++)
+ {
+ if ((i % 16) == 0)
+ {
+ if (ptr != line)
+ {
+ *ptr = '\0';
+ DBG (level, "%s\n", line);
+ ptr = line;
+ }
+ sprintf (ptr, "%3.3x:", i);
+ ptr += 4;
+ }
+ sprintf (ptr, " %2.2x", *p);
+ ptr += 3;
+ }
+ *ptr = '\0';
+ DBG (level, "%s\n", line);
+}
+
+/**
+ * An advanced method we don't support but have to define.
+ */
+SANE_Status
+sane_set_io_mode (SANE_Handle h, SANE_Bool non_blocking)
+{
+ DBG (10, "sane_set_io_mode\n");
+ DBG (15, "%d %p\n", non_blocking, h);
+ return SANE_STATUS_UNSUPPORTED;
+}
+
+/**
+ * An advanced method we don't support but have to define.
+ */
+SANE_Status
+sane_get_select_fd (SANE_Handle h, SANE_Int *fdp)
+{
+ DBG (10, "sane_get_select_fd\n");
+ DBG (15, "%p %d\n", h, *fdp);
+ return SANE_STATUS_UNSUPPORTED;
+}