New upstream version 1.3.0upstream/1.3.0upstream

1 files changed, 1287 insertions, 0 deletions

diff --git a/backend/lexmark_x2600.c b/backend/lexmark_x2600.c
new file mode 100644
index 0000000..610064e
--- /dev/null
+++ b/backend/lexmark_x2600.c
@@ -0,0 +1,1287 @@
+/* lexmark_x2600.c: SANE backend for Lexmark x2600 scanners.
+
+   (C) 2023 "Benoit Juin" <benoit.juin@gmail.com>
+
+   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, see <https://www.gnu.org/licenses/>.
+
+   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.
+
+   **************************************************************************/
+
+
+#include "lexmark_x2600.h"
+
+#define BUILD 1
+#define LEXMARK_X2600_CONFIG_FILE "lexmark_x2600.conf"
+#define MAX_OPTION_STRING_SIZE 255
+static SANE_Int transfer_buffer_size = 32768;
+static Lexmark_Device *first_device = 0;
+static SANE_Int num_devices = 0;
+static const SANE_Device **devlist = 0;
+
+static SANE_Bool initialized = SANE_FALSE;
+
+// first value is the size of the wordlist!
+static SANE_Int dpi_list[] = {
+  4, 100, 200, 300, 600
+};
+static SANE_Int dpi_list_size = sizeof(dpi_list) / sizeof(dpi_list[0]);
+
+static SANE_String_Const mode_list[] = {
+  SANE_VALUE_SCAN_MODE_COLOR,
+  SANE_VALUE_SCAN_MODE_GRAY,
+  NULL
+};
+
+static SANE_Range x_range = {
+  0,				/* minimum */
+  5078,				/* maximum */
+  1				/* quantization */
+};
+
+static SANE_Range y_range = {
+  0,				/* minimum */
+  7015,				/* maximum */
+  1				/* quantization */
+};
+
+static SANE_Byte command1_block[] = {
+  0xA5, 0x00, 0x19, 0x10, 0x01, 0x83, 0xAA, 0xBB,
+  0xCC, 0xDD, 0x02, 0x00, 0x1B, 0x53, 0x03, 0x00,
+  0x00, 0x00, 0x80, 0x00, 0xAA, 0xBB, 0xCC, 0xDD,
+  0xAA, 0xBB, 0xCC, 0xDD};
+static SANE_Int command1_block_size = sizeof(command1_block);
+
+static SANE_Byte command2_block[] = {
+  0xA5, 0x00, 0x19, 0x10, 0x01, 0x83, 0xAA, 0xBB,
+  0xCC, 0xDD, 0x02, 0x00, 0x1B, 0x53, 0x04, 0x00,
+  0x00, 0x00, 0x80, 0x00, 0xAA, 0xBB, 0xCC, 0xDD,
+  0xAA, 0xBB, 0xCC, 0xDD};
+static SANE_Int command2_block_size = sizeof(command2_block);
+
+static SANE_Byte command_with_params_block[] = {
+  0xA5, 0x00, 0x31, 0x10, 0x01, 0x83, 0xAA, 0xBB,
+  0xCC, 0xDD, 0x02, 0x00, 0x1B, 0x53, 0x05, 0x00,
+  0x18, 0x00, 0x80, 0x00, 0xFF, 0x00, 0x00, 0x02,
+  0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0xFF, 0xFF, 0xFF, 0xFF, 0xAA, 0xBB, 0xCC, 0xDD,
+  0xAA, 0xBB, 0xCC, 0xDD};
+static SANE_Int command_with_params_block_size = sizeof(command_with_params_block);
+
+static SANE_Byte command_cancel1_block[] = {
+  0xa5, 0x00, 0x19, 0x10, 0x01, 0x83, 0xaa, 0xbb,
+  0xcc, 0xdd, 0x02, 0x00, 0x1b, 0x53, 0x0f, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0xaa, 0xbb, 0xcc, 0xdd,
+  0xaa, 0xbb, 0xcc, 0xdd};
+static SANE_Byte command_cancel2_block[] = {
+  0xa5, 0x00, 0x19, 0x10, 0x01, 0x83, 0xaa, 0xbb,
+  0xcc, 0xdd, 0x02, 0x00, 0x1b, 0x53, 0x06, 0x00,
+  0x00, 0x00, 0x80, 0x00, 0xaa, 0xbb, 0xcc, 0xdd,
+  0xaa, 0xbb, 0xcc, 0xdd};
+static SANE_Int command_cancel_size = sizeof(command_cancel1_block);
+
+static SANE_Byte empty_line_data_packet[] = {
+  0x1b, 0x53, 0x02, 0x00, 0x01, 0x00, 0x00, 0x00,
+  0x00};
+static SANE_Int empty_line_data_packet_size = sizeof(empty_line_data_packet);
+
+static SANE_Byte last_data_packet[] = {
+  0x1b, 0x53, 0x02, 0x00, 0x01, 0x00, 0x00, 0x00,
+  0x01};
+static SANE_Int last_data_packet_size = sizeof(last_data_packet);
+
+static SANE_Byte cancel_packet[] = {
+  0x1b, 0x53, 0x02, 0x00, 0x01, 0x00, 0x00, 0x00,
+  0x03};
+static SANE_Int cancel_packet_size = sizeof(cancel_packet);
+
+static SANE_Byte linebegin_data_packet[] = {
+  0x1b, 0x53, 0x02, 0x00};
+static SANE_Int linebegin_data_packet_size = sizeof(linebegin_data_packet);
+
+static SANE_Byte unknown_a_data_packet[] = {
+  0x1b, 0x53, 0x01, 0x00, 0x01, 0x00, 0x80, 0x00};
+static SANE_Int unknown_a_data_packet_size = sizeof(unknown_a_data_packet);
+
+static SANE_Byte unknown_b_data_packet[] = {
+  0x1b, 0x53, 0x04, 0x00, 0x00, 0x00, 0x80, 0x00};
+static SANE_Int unknown_b_data_packet_size = sizeof(unknown_b_data_packet);
+
+static SANE_Byte unknown_c_data_packet[] = {
+  0x1b, 0x53, 0x04, 0x00, 0x00, 0x00, 0x84, 0x00};
+static SANE_Int unknown_c_data_packet_size = sizeof(unknown_c_data_packet);
+
+static SANE_Byte unknown_d_data_packet[] = {
+  0x1b, 0x53, 0x05, 0x00, 0x00, 0x00};
+static SANE_Int unknown_d_data_packet_size = sizeof(unknown_d_data_packet);
+
+static SANE_Byte unknown_e_data_packet[] = {
+  0xa5, 0x00, 0x06, 0x10, 0x01, 0xaa, 0xbb, 0xcc,
+  0xdd};
+static SANE_Int unknown_e_data_packet_size = sizeof(unknown_e_data_packet);
+
+/* static SANE_Byte not_ready_data_packet[] = { */
+/*   0x1b, 0x53, 0x01, 0x00, 0x01, 0x00, 0x84, 0x00}; */
+/* static SANE_Int not_ready_data_packet_size = sizeof(not_ready_data_packet); */
+
+
+static SANE_Int line_header_length = 9;
+
+
+//static SANE_Byte empty_data_packet[8] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
+
+SANE_Status
+clean_and_copy_data(const SANE_Byte * source, SANE_Int source_size,
+                    SANE_Byte * destination, SANE_Int * destination_length,
+                    SANE_Int mode, SANE_Int max_length, SANE_Handle dev)
+{
+  DBG (10, "clean_and_copy_data\n");
+  // if source doesnt start with 1b 53 02, then it is a continuation packet
+  // SANE_Int k = 0;
+  // SANE_Int bytes_written = 0;
+  // BW    1b 53 02 00 21 00 00 00 00  |   32 |   21 ->    33 (segmentlng=   32)
+  // BW    1b 53 02 00 41 00 00 00 00  |   64 |   41 ->    65 (segmentlng=   64)
+  // COLOR 1b 53 02 00 c1 00 00 00 00  |   64 |   c1 ->   193 (segmentlng=  192)
+  // COLOR 1b 53 02 00 01 06 00 00 00  |  512 |  601 ->  1537 (segmentlng= 1536)
+  // COLOR 1b 53 02 00 99 3a 00 00 00  | 5000 | 3a99 -> 15001 (segmentlng=15000)
+  // COLOR 1b 53 02 00 f7 0f 00        | 1362 | 0ff7 ->  4087 <- limit where sane_read can a read a line at e time, more that 1362 and then the rest
+  //                                                             of the line will be available in the next sane_read call
+  // COLOR 1b 53 02 00 fa 0f 00        |      | 0ffa ->  4090 <- in that case the line doesnt fit, clean_and_copy_data will be called again with the rest of the data
+
+
+  // edge case segment doesn(t feet in the packet size
+  /* if(segment_length > source_size - 9) */
+  /*   segment_length = source_size - 9; */
+
+  // the scanner sends series of 8 lines function param source
+  // every lines has prefix see linebegin_data_packet
+  // the source parameter as a limited length :function param source_size
+  // so the serie og 8 lines can be splited
+  // in such case, in the next call of this function, source contain the end of the
+  // broken segment.
+  // Here is the way data is read:
+  // 1 - check that source begin with a linebegin_data_packet signature
+  //     if this is the case the source[4] & source[5] contains how much data
+  //     can be read before onother header is reach (linebegin_data_packet)
+
+  Lexmark_Device * ldev = (Lexmark_Device * ) dev;
+  SANE_Int i = 0;
+  SANE_Int bytes_read = 0;
+  SANE_Byte tmp = 0;
+  SANE_Int source_read_cursor = 0;
+  SANE_Int block_pixel_data_length = 0;
+  SANE_Int size_to_realloc = 0;
+
+
+  if(!ldev->eof){
+
+    // does source start with linebegin_data_packet?
+    if (memcmp(linebegin_data_packet, source, linebegin_data_packet_size) == 0){
+      // extract the number of bytes we can read befor new header is reached
+      // store it in the device in case of continuation packet
+      ldev->read_buffer->linesize = (source[4] + ((source[5] << 8) & 0xFF00)) - 1;
+      ldev->read_buffer->last_line_bytes_read = ldev->read_buffer->linesize;
+      DBG (10, "    this is the begining of a line linesize=%ld\n",
+           ldev->read_buffer->linesize);
+    } else {
+      DBG (10, "    this is not a new line packet, continue to fill the read buffer\n");
+      //return;
+    }
+
+    if(ldev->read_buffer->linesize == 0){
+      DBG (10, "    linesize=0 something went wrong, lets ignore that USB packet\n");
+      return SANE_STATUS_CANCELLED;
+    }
+
+
+    // loop over source buffer
+    while(i < source_size){
+      // last line was full
+      if(ldev->read_buffer->last_line_bytes_read == ldev->read_buffer->linesize){
+        // if next block fit in the source
+        if(i + line_header_length + (SANE_Int) ldev->read_buffer->linesize <= source_size){
+          ldev->read_buffer->image_line_no += 1;
+          source_read_cursor = i + line_header_length;
+          block_pixel_data_length = ldev->read_buffer->linesize;
+          ldev->read_buffer->last_line_bytes_read = block_pixel_data_length;
+          size_to_realloc = ldev->read_buffer->image_line_no *
+            ldev->read_buffer->linesize * sizeof(SANE_Byte);
+          bytes_read = block_pixel_data_length + line_header_length;
+        }
+        // next block cannot be read fully because source_size is too small
+        // (USB packet fragmentation)
+        else{
+          ldev->read_buffer->image_line_no += 1;
+          source_read_cursor = i + line_header_length;
+          block_pixel_data_length = source_size - i - line_header_length;
+          ldev->read_buffer->last_line_bytes_read = block_pixel_data_length;
+          size_to_realloc = ((ldev->read_buffer->image_line_no-1) *
+            ldev->read_buffer->linesize + block_pixel_data_length) * sizeof(SANE_Byte);
+          bytes_read = block_pixel_data_length + line_header_length;
+        }
+      }
+      // last line was not full lets extract what is left
+      // this is du to USB packet fragmentation
+      else{
+        // the last line was not full so no increment
+        ldev->read_buffer->image_line_no += 0;
+        source_read_cursor = i;
+        block_pixel_data_length = ldev->read_buffer->linesize -
+          ldev->read_buffer->last_line_bytes_read;
+        // we completed the last line with missing bytes so new the line is full
+        ldev->read_buffer->last_line_bytes_read = ldev->read_buffer->linesize;
+        size_to_realloc = ldev->read_buffer->image_line_no *
+          ldev->read_buffer->linesize * sizeof(SANE_Byte);
+        bytes_read = block_pixel_data_length;
+      }
+
+      DBG (20, "    size_to_realloc=%d i=%d image_line_no=%d\n",
+           size_to_realloc, i, ldev->read_buffer->image_line_no);
+      // do realoc memory space for our buffer
+      SANE_Byte* alloc_result = realloc(ldev->read_buffer->data, size_to_realloc);
+      if(alloc_result == NULL){
+        // TODO allocation was not possible
+        DBG (20, "    REALLOC failed\n");
+        return SANE_STATUS_NO_MEM;
+      }
+      // point data to our new memary space
+      ldev->read_buffer->data = alloc_result;
+      // reposition writeptr and readptr to the correct memory adress
+      // to do that use write_byte_counter and read_byte_counter
+      ldev->read_buffer->writeptr =
+        ldev->read_buffer->data + ldev->read_buffer->write_byte_counter;
+      // copy new data
+      memcpy(
+             ldev->read_buffer->writeptr,
+             source + source_read_cursor,
+             block_pixel_data_length
+      );
+
+      // store how long is the buffer
+      ldev->read_buffer->write_byte_counter += block_pixel_data_length;
+
+      i += bytes_read;
+    }
+  }
+
+  // reposition our readptr
+  ldev->read_buffer->readptr =
+    ldev->read_buffer->data + ldev->read_buffer->read_byte_counter;
+
+
+  // read our buffer to fill the destination buffer
+  // mulitple call so read may has been already started
+  // length already read is stored in ldev->read_buffer->read_byte_counter
+
+  SANE_Int available_bytes_to_read =
+    ldev->read_buffer->write_byte_counter - ldev->read_buffer->read_byte_counter;
+
+  DBG (20, "    source read done now sending to destination \n");
+
+  // we will copy image data 3 bytes by 3 bytes if color mod to allow color swap
+  // this avoid error on color channels swapping
+  if (mode == SANE_FRAME_RGB){
+
+    // get max chunk
+    SANE_Int data_chunk_size = max_length;
+    if(data_chunk_size > available_bytes_to_read){
+      data_chunk_size = available_bytes_to_read;
+    }
+    data_chunk_size = data_chunk_size / 3;
+    data_chunk_size = data_chunk_size * 3;
+
+    // we have to invert color channels
+    SANE_Byte * color_swarp_ptr = ldev->read_buffer->readptr;
+    for(SANE_Int j=0; j < data_chunk_size;j += 3){
+      // DBG (20, "  swapping RGB <- BGR j=%d\n", j);
+      tmp = *(color_swarp_ptr + j);
+      *(color_swarp_ptr + j) = *(color_swarp_ptr + j + 2);
+      *(color_swarp_ptr + j + 2) = tmp;
+    }
+
+    memcpy (destination,
+            ldev->read_buffer->readptr,
+            data_chunk_size);
+
+    ldev->read_buffer->read_byte_counter += data_chunk_size;
+    *destination_length = data_chunk_size;
+
+  }
+  // gray mode copy until max_length
+  else{
+
+    SANE_Int data_chunk_size = max_length;
+    if(data_chunk_size > available_bytes_to_read){
+      data_chunk_size = available_bytes_to_read;
+    }
+    memcpy (
+      destination,
+      ldev->read_buffer->readptr,
+      data_chunk_size
+    );
+    ldev->read_buffer->read_byte_counter += data_chunk_size;;
+    *destination_length = data_chunk_size;
+
+  }
+
+  DBG (20, "    done destination_length=%d available_bytes_to_read=%d\n",
+       *destination_length, available_bytes_to_read);
+
+  if(available_bytes_to_read > 0){
+    return SANE_STATUS_GOOD;
+  }else{
+    ldev->eof = 0;
+    return SANE_STATUS_EOF;
+  }
+
+}
+
+SANE_Status
+usb_write_then_read (Lexmark_Device * dev, SANE_Byte * cmd, size_t cmd_size)
+{
+  size_t buf_size = 256;
+  SANE_Byte buf[buf_size];
+  SANE_Status status;
+
+  DBG (10, "usb_write_then_read: %d\n", dev->devnum);
+  sanei_usb_set_endpoint(dev->devnum, USB_DIR_OUT|USB_ENDPOINT_TYPE_BULK, 0x02);
+  DBG (10, "    endpoint set: %d\n", dev->devnum);
+
+  /* status = sanei_usb_read_bulk (dev->devnum, buf, &buf_size); */
+  /* DBG (10, "    readdone: %d\n", dev->devnum); */
+  /* if (status != SANE_STATUS_GOOD && status != SANE_STATUS_EOF) */
+  /*   { */
+  /*     DBG (1, "USB READ IO Error in usb_write_then_read, fail devnum=%d\n", */
+  /*          dev->devnum); */
+  /*     return status; */
+  /*   } */
+
+  DBG (10, "    attempting to write...: %d\n", dev->devnum);
+  status = sanei_usb_write_bulk (dev->devnum, cmd, &cmd_size);
+  DBG (10, "    writedone: %d\n", dev->devnum);
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG (1, "USB WRITE IO Error in usb_write_then_read, launch fail: %d\n",
+           status);
+      return status;
+    }
+
+  debug_packet(cmd, cmd_size, WRITE);
+
+  DBG (10, "    attempting to read...: %d\n", dev->devnum);
+  status = sanei_usb_read_bulk (dev->devnum, buf, &buf_size);
+  DBG (10, "    readdone: %d\n", dev->devnum);
+  if (status != SANE_STATUS_GOOD && status != SANE_STATUS_EOF)
+    {
+      DBG (1, "USB READ IO Error in usb_write_then_read, fail devnum=%d\n",
+           dev->devnum);
+      return status;
+    }
+  debug_packet(buf, buf_size, READ);
+  return SANE_STATUS_GOOD;
+}
+
+void
+build_packet(Lexmark_Device * dev, SANE_Byte packet_id, SANE_Byte * buffer){
+  memcpy(buffer, command_with_params_block, command_with_params_block_size);
+  // protocole related... "ID?"
+  buffer[14] = packet_id;
+
+  // mode
+  if (memcmp(dev->val[OPT_MODE].s, "Color", 5) == 0 )
+    buffer[20] = 0x03;
+  else
+    buffer[20] = 0x02;
+
+  // pixel width (swap lower byte -> higher byte)
+  buffer[24] = dev->val[OPT_BR_X].w & 0xFF;
+  buffer[25] = (dev->val[OPT_BR_X].w >> 8) & 0xFF;
+
+  // pixel height (swap lower byte -> higher byte)
+  buffer[28] = dev->val[OPT_BR_Y].w & 0xFF;
+  buffer[29] = (dev->val[OPT_BR_Y].w >> 8) & 0xFF;
+
+  // dpi x (swap lower byte -> higher byte)
+  buffer[40] = dev->val[OPT_RESOLUTION].w & 0xFF;
+  buffer[41] = (dev->val[OPT_RESOLUTION].w >> 8) & 0xFF;
+
+  // dpi y (swap lower byte -> higher byte)
+  buffer[42] = dev->val[OPT_RESOLUTION].w & 0xFF;
+  buffer[43] = (dev->val[OPT_RESOLUTION].w >> 8) & 0xFF;
+}
+
+SANE_Status
+init_options (Lexmark_Device * dev)
+{
+
+  SANE_Option_Descriptor *od;
+
+  DBG (2, "init_options: dev = %p\n", (void *) dev);
+
+  /* number of options */
+  od = &(dev->opt[OPT_NUM_OPTS]);
+  od->name = SANE_NAME_NUM_OPTIONS;
+  od->title = SANE_TITLE_NUM_OPTIONS;
+  od->desc = SANE_DESC_NUM_OPTIONS;
+  od->type = SANE_TYPE_INT;
+  od->unit = SANE_UNIT_NONE;
+  od->size = sizeof (SANE_Word);
+  od->cap = SANE_CAP_SOFT_DETECT;
+  od->constraint_type = SANE_CONSTRAINT_NONE;
+  od->constraint.range = 0;
+  dev->val[OPT_NUM_OPTS].w = NUM_OPTIONS;
+
+  /* mode - sets the scan mode: Color / Gray */
+  od = &(dev->opt[OPT_MODE]);
+  od->name = SANE_NAME_SCAN_MODE;
+  od->title = SANE_TITLE_SCAN_MODE;
+  od->desc = SANE_DESC_SCAN_MODE;;
+  od->type = SANE_TYPE_STRING;
+  od->unit = SANE_UNIT_NONE;
+  od->size = MAX_OPTION_STRING_SIZE;
+  od->cap = SANE_CAP_SOFT_DETECT | SANE_CAP_SOFT_SELECT;
+  od->constraint_type = SANE_CONSTRAINT_STRING_LIST;
+  od->constraint.string_list = mode_list;
+  dev->val[OPT_MODE].s = malloc (od->size);
+  if (!dev->val[OPT_MODE].s)
+    return SANE_STATUS_NO_MEM;
+  strcpy (dev->val[OPT_MODE].s, SANE_VALUE_SCAN_MODE_COLOR);
+
+  /* resolution */
+  od = &(dev->opt[OPT_RESOLUTION]);
+  od->name = SANE_NAME_SCAN_RESOLUTION;
+  od->title = SANE_TITLE_SCAN_RESOLUTION;
+  od->desc = SANE_DESC_SCAN_RESOLUTION;
+  od->type = SANE_TYPE_INT;
+  od->unit = SANE_UNIT_DPI;
+  od->size = sizeof (SANE_Int);
+  od->cap = SANE_CAP_SOFT_DETECT | SANE_CAP_SOFT_SELECT;
+  od->constraint_type = SANE_CONSTRAINT_WORD_LIST;
+  od->constraint.word_list = dpi_list;
+  dev->val[OPT_RESOLUTION].w = 200;
+
+  /* preview mode */
+  od = &(dev->opt[OPT_PREVIEW]);
+  od->name = SANE_NAME_PREVIEW;
+  od->title = SANE_TITLE_PREVIEW;
+  od->desc = SANE_DESC_PREVIEW;
+  od->size = sizeof (SANE_Word);
+  od->cap = SANE_CAP_INACTIVE;
+  od->type = SANE_TYPE_BOOL;
+  od->constraint_type = SANE_CONSTRAINT_NONE;
+  dev->val[OPT_PREVIEW].w = SANE_FALSE;
+
+  /* "Geometry" group: */
+  od = &(dev->opt[OPT_GEOMETRY_GROUP]);
+  od->name = "";
+  od->title = SANE_I18N ("Geometry");
+  od->desc = "";
+  od->type = SANE_TYPE_GROUP;
+  od->cap = SANE_CAP_SOFT_DETECT | SANE_CAP_SOFT_SELECT;
+  od->size = 0;
+  od->constraint_type = SANE_CONSTRAINT_NONE;
+  //
+
+  /* top-left x */
+  od = &(dev->opt[OPT_TL_X]);
+  od->name = SANE_NAME_SCAN_TL_X;
+  od->title = SANE_TITLE_SCAN_TL_X;
+  od->desc = SANE_DESC_SCAN_TL_X;
+  od->type = SANE_TYPE_INT;
+  od->cap = SANE_CAP_INACTIVE;
+  od->size = sizeof (SANE_Word);
+  od->unit = SANE_UNIT_PIXEL;
+  od->constraint_type = SANE_CONSTRAINT_RANGE;
+  od->constraint.range = &x_range;
+  dev->val[OPT_TL_X].w = 0;
+
+  /* top-left y */
+  od = &(dev->opt[OPT_TL_Y]);
+  od->name = SANE_NAME_SCAN_TL_Y;
+  od->title = SANE_TITLE_SCAN_TL_Y;
+  od->desc = SANE_DESC_SCAN_TL_Y;
+  od->type = SANE_TYPE_INT;
+  od->cap = SANE_CAP_INACTIVE;
+  od->size = sizeof (SANE_Word);
+  od->unit = SANE_UNIT_PIXEL;
+  od->constraint_type = SANE_CONSTRAINT_RANGE;
+  od->constraint.range = &y_range;
+  dev->val[OPT_TL_Y].w = 0;
+
+  /* bottom-right x */
+  od = &(dev->opt[OPT_BR_X]);
+  od->name = SANE_NAME_SCAN_BR_X;
+  od->title = SANE_TITLE_SCAN_BR_X;
+  od->desc = SANE_DESC_SCAN_BR_X;
+  od->type = SANE_TYPE_INT;
+  od->size = sizeof (SANE_Word);
+  od->cap = SANE_CAP_SOFT_DETECT | SANE_CAP_SOFT_SELECT;
+  od->unit = SANE_UNIT_PIXEL;
+  od->constraint_type = SANE_CONSTRAINT_RANGE;
+  od->constraint.range = &x_range;
+  dev->val[OPT_BR_X].w = 1654;
+
+  /* bottom-right y */
+  od = &(dev->opt[OPT_BR_Y]);
+  od->name = SANE_NAME_SCAN_BR_Y;
+  od->title = SANE_TITLE_SCAN_BR_Y;
+  od->desc = SANE_DESC_SCAN_BR_Y;
+  od->type = SANE_TYPE_INT;
+  od->size = sizeof (SANE_Word);
+  od->cap = SANE_CAP_SOFT_DETECT | SANE_CAP_SOFT_SELECT;
+  od->unit = SANE_UNIT_PIXEL;
+  od->constraint_type = SANE_CONSTRAINT_RANGE;
+  od->constraint.range = &y_range;
+  dev->val[OPT_BR_Y].w = 2339;
+
+  return SANE_STATUS_GOOD;
+}
+
+/* callback function for sanei_usb_attach_matching_devices
+*/
+static SANE_Status
+attach_one (SANE_String_Const devname)
+{
+  Lexmark_Device *lexmark_device;
+
+  DBG (2, "attach_one: attachLexmark: devname=%s first_device=%p\n",
+       devname, (void *)first_device);
+
+  for (lexmark_device = first_device; lexmark_device;
+       lexmark_device = lexmark_device->next){
+    /* already attached devices */
+
+    if (strcmp (lexmark_device->sane.name, devname) == 0){
+      lexmark_device->missing = SANE_FALSE;
+      return SANE_STATUS_GOOD;
+    }
+  }
+
+  lexmark_device = (Lexmark_Device *) malloc (sizeof (Lexmark_Device));
+  if (lexmark_device == NULL)
+    return SANE_STATUS_NO_MEM;
+
+  lexmark_device->sane.name = strdup (devname);
+  if (lexmark_device->sane.name == NULL)
+    return SANE_STATUS_NO_MEM;
+  lexmark_device->sane.vendor = "Lexmark";
+  lexmark_device->sane.model = "X2600 series";
+  lexmark_device->sane.type = "flat bed";
+
+  /* init transfer_buffer */
+  lexmark_device->transfer_buffer = malloc (transfer_buffer_size);
+  if (lexmark_device->transfer_buffer == NULL)
+    return SANE_STATUS_NO_MEM;
+
+  /* Make the pointer to the read buffer null here */
+  lexmark_device->read_buffer = malloc (sizeof (Read_Buffer));
+  if (lexmark_device->read_buffer == NULL)
+    return SANE_STATUS_NO_MEM;
+
+  /* mark device as present */
+  lexmark_device->missing = SANE_FALSE;
+  lexmark_device->device_cancelled = SANE_FALSE;
+  /* insert it a the start of the chained list */
+  lexmark_device->next = first_device;
+  first_device = lexmark_device;
+  num_devices++;
+  DBG (2, "    first_device=%p\n", (void *)first_device);
+
+  return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+scan_devices(){
+  DBG (2, "scan_devices\n");
+  SANE_Char config_line[PATH_MAX];
+  FILE *fp;
+  const char *lp;
+  num_devices = 0;
+
+  // -- free existing device we are doning a full re-scan
+  while (first_device){
+    Lexmark_Device *this_device = first_device;
+    first_device = first_device->next;
+    DBG (2, "    free first_device\n");
+    free(this_device);
+  }
+
+  fp = sanei_config_open (LEXMARK_X2600_CONFIG_FILE);
+  if (!fp)
+    {
+      DBG (2, "    No config no prob...(%s)\n", LEXMARK_X2600_CONFIG_FILE);
+      return SANE_STATUS_GOOD;
+    }
+  while (sanei_config_read (config_line, sizeof (config_line), fp))
+    {
+      if (config_line[0] == '#')
+    continue;		/* ignore line comments */
+
+      lp = sanei_config_skip_whitespace (config_line);
+      /* skip empty lines */
+      if (*lp == 0)
+    continue;
+
+      DBG (4, "    attach_matching_devices(%s)\n", config_line);
+      sanei_usb_init();
+      sanei_usb_attach_matching_devices (config_line, attach_one);
+    }
+
+  fclose (fp);
+  return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+sane_init (SANE_Int *version_code, SANE_Auth_Callback authorize)
+{
+  DBG_INIT ();
+  DBG (2, "sane_init: version_code %s 0, authorize %s 0\n",
+       version_code == 0 ? "=" : "!=", authorize == 0 ? "=" : "!=");
+  DBG (1, "    SANE lexmark_x2600 backend version %d.%d.%d from %s\n",
+       SANE_CURRENT_MAJOR, SANE_CURRENT_MINOR, BUILD, PACKAGE_STRING);
+
+  if (version_code)
+    *version_code = SANE_VERSION_CODE (SANE_CURRENT_MAJOR, SANE_CURRENT_MINOR, BUILD);
+
+
+  SANE_Status status = scan_devices();
+  initialized = SANE_TRUE;
+  return status;
+}
+
+SANE_Status
+sane_get_devices (const SANE_Device ***device_list, SANE_Bool local_only)
+{
+  SANE_Int index;
+  Lexmark_Device *lexmark_device;
+
+  DBG (2, "sane_get_devices: device_list=%p, local_only=%d num_devices=%d\n",
+       (void *) device_list, local_only, num_devices);
+
+  //sanei_usb_scan_devices ();
+  SANE_Status status = scan_devices();
+
+  if (devlist)
+    free (devlist);
+
+  devlist = malloc ((num_devices + 1) * sizeof (devlist[0]));
+  if (!devlist)
+    return (SANE_STATUS_NO_MEM);
+
+  index = 0;
+  lexmark_device = first_device;
+  while (lexmark_device != NULL)
+    {
+      DBG (2, "    lexmark_device->missing:%d\n",
+           lexmark_device->missing);
+      if (lexmark_device->missing == SANE_FALSE)
+    {
+
+      devlist[index] = &(lexmark_device->sane);
+      index++;
+    }
+      lexmark_device = lexmark_device->next;
+    }
+  devlist[index] = 0;
+
+  *device_list = devlist;
+
+  return status;
+}
+
+SANE_Status
+sane_open (SANE_String_Const devicename, SANE_Handle * handle)
+{
+  Lexmark_Device *lexmark_device;
+  SANE_Status status;
+
+  DBG (2, "sane_open: devicename=\"%s\", handle=%p\n", devicename,
+       (void *) handle);
+
+  /* walk the linked list of scanner device until there is a match
+   * with the device name */
+  for (lexmark_device = first_device; lexmark_device;
+       lexmark_device = lexmark_device->next)
+    {
+      DBG (10, "    devname from list: %s\n",
+       lexmark_device->sane.name);
+      if (strcmp (devicename, "") == 0
+      || strcmp (devicename, "lexmark") == 0
+      || strcmp (devicename, lexmark_device->sane.name) == 0)
+    break;
+    }
+
+  *handle = lexmark_device;
+
+  status = init_options (lexmark_device);
+  if (status != SANE_STATUS_GOOD)
+    return status;
+
+  DBG(2, "    device `%s' opening devnum: '%d'\n",
+      lexmark_device->sane.name, lexmark_device->devnum);
+  status = sanei_usb_open (lexmark_device->sane.name, &(lexmark_device->devnum));
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG (1, "     couldn't open device `%s': %s\n",
+           lexmark_device->sane.name,
+       sane_strstatus (status));
+      return status;
+    }
+  else
+    {
+      DBG (2, "    device `%s' successfully opened devnum: '%d'\n",
+           lexmark_device->sane.name, lexmark_device->devnum);
+    }
+
+  return status;
+}
+
+const SANE_Option_Descriptor *
+sane_get_option_descriptor (SANE_Handle handle, SANE_Int option)
+{
+  Lexmark_Device *lexmark_device;
+
+  //DBG (2, "sane_get_option_descriptor: handle=%p, option = %d\n",
+  //     (void *) handle, option);
+
+  /* Check for valid option number */
+  if ((option < 0) || (option >= NUM_OPTIONS))
+    return NULL;
+
+  for (lexmark_device = first_device; lexmark_device;
+       lexmark_device = lexmark_device->next)
+    {
+      if (lexmark_device == handle)
+    break;
+    }
+
+  if (!lexmark_device)
+    return NULL;
+
+  if (lexmark_device->opt[option].name)
+    {
+      //DBG (2, "    name=%s\n",
+      //     lexmark_device->opt[option].name);
+    }
+
+  return &(lexmark_device->opt[option]);
+}
+
+SANE_Status
+sane_control_option (SANE_Handle handle, SANE_Int option, SANE_Action action,
+                     void * value, SANE_Word * info)
+{
+  Lexmark_Device *lexmark_device;
+  SANE_Status status;
+  SANE_Word w;
+  SANE_Int res_selected;
+
+  DBG (2, "sane_control_option: handle=%p, opt=%d, act=%d, val=%p, info=%p\n",
+       (void *) handle, option, action, (void *) value, (void *) info);
+
+  for (lexmark_device = first_device; lexmark_device;
+       lexmark_device = lexmark_device->next){
+    if (lexmark_device == handle)
+      break;
+  }
+
+
+  if (value == NULL)
+    return SANE_STATUS_INVAL;
+
+  switch (action){
+  case SANE_ACTION_SET_VALUE:
+    if (!SANE_OPTION_IS_SETTABLE (lexmark_device->opt[option].cap)){
+      return SANE_STATUS_INVAL;
+    }
+    /* Make sure boolean values are only TRUE or FALSE */
+    if (lexmark_device->opt[option].type == SANE_TYPE_BOOL){
+      if (!
+          ((*(SANE_Bool *) value == SANE_FALSE)
+           || (*(SANE_Bool *) value == SANE_TRUE)))
+        return SANE_STATUS_INVAL;
+    }
+
+    /* Check range constraints */
+    if (lexmark_device->opt[option].constraint_type ==
+        SANE_CONSTRAINT_RANGE){
+      status =
+        sanei_constrain_value (&(lexmark_device->opt[option]), value,
+                               info);
+      if (status != SANE_STATUS_GOOD){
+        DBG (2, "    SANE_CONTROL_OPTION: Bad value for range\n");
+        return SANE_STATUS_INVAL;
+      }
+    }
+    switch (option){
+    case OPT_NUM_OPTS:
+    case OPT_RESOLUTION:
+      res_selected = *(SANE_Int *) value;
+      // first value is the size of the wordlist!
+      for(int i=1; i<dpi_list_size; i++){
+        DBG (10, "    posible res=%d selected=%d\n", dpi_list[i], res_selected);
+        if(res_selected == dpi_list[i]){
+          lexmark_device->val[option].w = *(SANE_Word *) value;
+        }
+      }
+      break;
+    case OPT_TL_X:
+    case OPT_TL_Y:
+    case OPT_BR_X:
+    case OPT_BR_Y:
+      DBG (2, "    Option value set to %d (%s)\n", *(SANE_Word *) value,
+           lexmark_device->opt[option].name);
+      lexmark_device->val[option].w = *(SANE_Word *) value;
+      if (lexmark_device->val[OPT_TL_X].w >
+          lexmark_device->val[OPT_BR_X].w){
+        w = lexmark_device->val[OPT_TL_X].w;
+        lexmark_device->val[OPT_TL_X].w =
+          lexmark_device->val[OPT_BR_X].w;
+        lexmark_device->val[OPT_BR_X].w = w;
+        if (info)
+          *info |= SANE_INFO_RELOAD_PARAMS;
+      }
+      if (lexmark_device->val[OPT_TL_Y].w >
+          lexmark_device->val[OPT_BR_Y].w){
+        w = lexmark_device->val[OPT_TL_Y].w;
+        lexmark_device->val[OPT_TL_Y].w =
+          lexmark_device->val[OPT_BR_Y].w;
+        lexmark_device->val[OPT_BR_Y].w = w;
+        if (info)
+          *info |= SANE_INFO_RELOAD_PARAMS;
+      }
+      break;
+    case OPT_MODE:
+      strcpy (lexmark_device->val[option].s, value);
+      if (info)
+        *info |= SANE_INFO_RELOAD_PARAMS | SANE_INFO_RELOAD_OPTIONS;
+      return SANE_STATUS_GOOD;
+    }
+
+
+    if (info != NULL)
+      *info |= SANE_INFO_RELOAD_PARAMS;
+
+    break;
+  case SANE_ACTION_GET_VALUE:
+    switch (option){
+    case OPT_NUM_OPTS:
+    case OPT_RESOLUTION:
+    case OPT_PREVIEW:
+    case OPT_TL_X:
+    case OPT_TL_Y:
+    case OPT_BR_X:
+    case OPT_BR_Y:
+      *(SANE_Word *) value = lexmark_device->val[option].w;
+      //DBG (2, "    Option value = %d (%s)\n", *(SANE_Word *) value,
+      //     lexmark_device->opt[option].name);
+      break;
+    case OPT_MODE:
+      strcpy (value, lexmark_device->val[option].s);
+      break;
+    }
+    break;
+
+  default:
+    return SANE_STATUS_INVAL;
+  }
+
+  return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+sane_get_parameters (SANE_Handle handle, SANE_Parameters * params)
+{
+  Lexmark_Device *lexmark_device;
+  SANE_Parameters *device_params;
+  SANE_Int width_px;
+
+  DBG (2, "sane_get_parameters: handle=%p, params=%p\n", (void *) handle,
+       (void *) params);
+
+  for (lexmark_device = first_device; lexmark_device;
+       lexmark_device = lexmark_device->next)
+    {
+      if (lexmark_device == handle)
+    break;
+    }
+
+  if (!lexmark_device)
+    return SANE_STATUS_INVAL;
+
+  // res = lexmark_device->val[OPT_RESOLUTION].w;
+  device_params = &(lexmark_device->params);
+
+  width_px =
+    lexmark_device->val[OPT_BR_X].w - lexmark_device->val[OPT_TL_X].w;
+
+  /* 24 bit colour = 8 bits/channel for each of the RGB channels */
+  device_params->pixels_per_line = width_px;
+  device_params->format = SANE_FRAME_RGB; // SANE_FRAME_GRAY
+  device_params->depth = 8;
+  device_params->bytes_per_line =
+    (SANE_Int) (3 * device_params->pixels_per_line);
+
+  if (strcmp (lexmark_device->val[OPT_MODE].s, SANE_VALUE_SCAN_MODE_COLOR)
+      != 0)
+    {
+      device_params->format = SANE_FRAME_GRAY;
+      device_params->bytes_per_line =
+        (SANE_Int) (device_params->pixels_per_line);
+    }
+
+  /* geometry in pixels */
+  device_params->last_frame = SANE_TRUE;
+  device_params->lines = -1;//lexmark_device->val[OPT_BR_Y].w;
+
+  DBG (2, "    device_params->pixels_per_line=%d\n",
+       device_params->pixels_per_line);
+  DBG (2, "    device_params->bytes_per_line=%d\n",
+       device_params->bytes_per_line);
+  DBG (2, "    device_params->depth=%d\n",
+       device_params->depth);
+  DBG (2, "    device_params->format=%d\n",
+       device_params->format);
+  DBG (2, "      SANE_FRAME_GRAY: %d\n",
+       SANE_FRAME_GRAY);
+  DBG (2, "      SANE_FRAME_RGB: %d\n",
+       SANE_FRAME_RGB);
+
+  if (params != 0)
+    {
+      params->format = device_params->format;
+      params->last_frame = device_params->last_frame;
+      params->lines = device_params->lines;
+      params->depth = device_params->depth;
+      params->pixels_per_line = device_params->pixels_per_line;
+      params->bytes_per_line = device_params->bytes_per_line;
+    }
+  return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+sane_start (SANE_Handle handle)
+{
+  Lexmark_Device * lexmark_device;
+  SANE_Status status;
+  SANE_Byte * cmd = (SANE_Byte *) malloc
+    (command_with_params_block_size * sizeof (SANE_Byte));
+  if (cmd == NULL)
+    return SANE_STATUS_NO_MEM;
+
+  DBG (2, "sane_start: handle=%p initialized=%d\n", (void *) handle, initialized);
+
+  if (!initialized)
+    return SANE_STATUS_INVAL;
+
+  for (lexmark_device = first_device; lexmark_device;
+       lexmark_device = lexmark_device->next)
+    {
+      if (lexmark_device == handle)
+    break;
+    }
+
+  if(lexmark_device == NULL){
+    DBG (2, "    Cannot find device\n");
+    free(cmd);
+    return SANE_STATUS_IO_ERROR;
+  }
+
+  lexmark_device->read_buffer->data = NULL;
+  lexmark_device->read_buffer->size = 0;
+  lexmark_device->read_buffer->last_line_bytes_read = 0;
+  lexmark_device->read_buffer->image_line_no = 0;
+  lexmark_device->read_buffer->write_byte_counter = 0;
+  lexmark_device->read_buffer->read_byte_counter = 0;
+  lexmark_device->eof = SANE_FALSE;
+  lexmark_device->device_cancelled = SANE_FALSE;
+
+  //launch scan commands
+  status = usb_write_then_read(lexmark_device, command1_block,
+                               command1_block_size);
+  if (status != SANE_STATUS_GOOD){
+    free(cmd);
+    return status;
+  }
+  status = usb_write_then_read(lexmark_device, command2_block,
+                               command2_block_size);
+  if (status != SANE_STATUS_GOOD){
+    free(cmd);
+    return status;
+  }
+  build_packet(lexmark_device, 0x05, cmd);
+  status = usb_write_then_read(lexmark_device, cmd,
+                               command_with_params_block_size);
+  if (status != SANE_STATUS_GOOD){
+    free(cmd);
+    return status;
+  }
+  build_packet(lexmark_device, 0x01, cmd);;
+  status = usb_write_then_read(lexmark_device, cmd,
+                               command_with_params_block_size);
+  if (status != SANE_STATUS_GOOD){
+    free(cmd);
+    return status;
+  }
+
+  free(cmd);
+  return SANE_STATUS_GOOD;
+}
+
+
+void debug_packet(const SANE_Byte * source, SANE_Int source_size, Debug_Packet dp){
+  if(dp == READ){
+    DBG (10, "source READ <<<  size=%d\n", source_size);
+  }else{
+    DBG (10, "source WRITE >>>  size=%d\n", source_size);
+  }
+
+  DBG (10, "       %02hhx %02hhx %02hhx %02hhx | %02hhx %02hhx %02hhx %02hhx \n",
+       source[0], source[1], source[2], source[3], source[4], source[5], source[6], source[7]);
+  DBG (10, "       %02hhx %02hhx %02hhx %02hhx | %02hhx %02hhx %02hhx %02hhx \n",
+       source[8], source[9], source[10], source[11], source[12], source[13], source[14], source[15]);
+  int debug_offset = 4092;
+  if(source_size > debug_offset){
+    DBG (10, "       %02hhx %02hhx %02hhx %02hhx | %02hhx %02hhx %02hhx %02hhx \n",
+         source[source_size-16-debug_offset],
+         source[source_size-15-debug_offset],
+         source[source_size-14-debug_offset],
+         source[source_size-13-debug_offset],
+         source[source_size-12-debug_offset],
+         source[source_size-11-debug_offset],
+         source[source_size-10-debug_offset],
+         source[source_size-9-debug_offset]);
+    DBG (10, "       %02hhx %02hhx %02hhx %02hhx | %02hhx %02hhx %02hhx %02hhx \n",
+         source[source_size-8-debug_offset],
+         source[source_size-7-debug_offset],
+         source[source_size-6-debug_offset],
+         source[source_size-5-debug_offset],
+         source[source_size-4-debug_offset],
+         source[source_size-3-debug_offset],
+         source[source_size-2-debug_offset],
+         source[source_size-1-debug_offset]);
+  }
+  return;
+}
+
+SANE_Status
+sane_read (SANE_Handle handle, SANE_Byte * data,
+       SANE_Int max_length, SANE_Int * length)
+{
+  Lexmark_Device * lexmark_device;
+  SANE_Status status;
+  size_t size = transfer_buffer_size;
+  //SANE_Byte buf[size];
+  DBG (1, "\n");
+  DBG (1, "sane_read max_length=%d:\n", max_length);
+
+  for (lexmark_device = first_device; lexmark_device;
+       lexmark_device = lexmark_device->next)
+    {
+      if (lexmark_device == handle)
+    break;
+    }
+
+  if (lexmark_device->device_cancelled == SANE_TRUE) {
+      DBG (10, "device_cancelled=True \n");
+      usb_write_then_read(lexmark_device, command_cancel1_block,
+                          command_cancel_size);
+      usb_write_then_read(lexmark_device, command_cancel2_block,
+                          command_cancel_size);
+      usb_write_then_read(lexmark_device, command_cancel1_block,
+                          command_cancel_size);
+      usb_write_then_read(lexmark_device, command_cancel2_block,
+                          command_cancel_size);
+      // to empty buffers
+      status = sanei_usb_read_bulk (
+          lexmark_device->devnum, lexmark_device->transfer_buffer, &size);
+      if(status == SANE_STATUS_GOOD){
+        status = sanei_usb_read_bulk (
+            lexmark_device->devnum, lexmark_device->transfer_buffer, &size);
+      }
+      if(status == SANE_STATUS_GOOD){
+        status = sanei_usb_read_bulk (
+            lexmark_device->devnum, lexmark_device->transfer_buffer, &size);
+      }
+
+      return status;
+  }
+
+  //status = sanei_usb_read_bulk (lexmark_device->devnum, buf, &size);
+  if(!lexmark_device->eof){
+      DBG (1, "    usb_read\n");
+      status = sanei_usb_read_bulk (
+          lexmark_device->devnum, lexmark_device->transfer_buffer, &size);
+      if (status != SANE_STATUS_GOOD && status != SANE_STATUS_EOF)
+        {
+          DBG (1, "    USB READ Error in sanei_usb_read_bulk, cannot read devnum=%d status=%d size=%ld\n",
+               lexmark_device->devnum, status, size);
+          return status;
+        }
+      DBG (1, "    usb_read done size=%ld\n", size);
+      debug_packet(lexmark_device->transfer_buffer, size, READ);
+  }else{
+    DBG (1, "    no usb_read eof reached\n");
+  }
+
+  // is last data packet ?
+  if (!lexmark_device->eof && memcmp(last_data_packet, lexmark_device->transfer_buffer, last_data_packet_size) == 0){
+
+    // we may still have data left to send in our buffer device->read_buffer->data
+    //length = 0;
+    //return SANE_STATUS_EOF;
+    lexmark_device->eof = SANE_TRUE;
+    DBG (1, "    EOF PACKET no more data from scanner\n");
+
+    return SANE_STATUS_GOOD;
+  }
+  // cancel packet received?
+  if (memcmp(cancel_packet, lexmark_device->transfer_buffer, cancel_packet_size) == 0){
+    length = 0;
+    return SANE_STATUS_CANCELLED;
+  }
+  if (memcmp(empty_line_data_packet, lexmark_device->transfer_buffer, empty_line_data_packet_size) == 0){
+    return SANE_STATUS_GOOD;
+  }
+  if (memcmp(unknown_a_data_packet, lexmark_device->transfer_buffer, unknown_a_data_packet_size) == 0){
+    return SANE_STATUS_GOOD;
+  }
+  if (memcmp(unknown_b_data_packet, lexmark_device->transfer_buffer, unknown_b_data_packet_size) == 0){
+    return SANE_STATUS_GOOD;
+  }
+  if (memcmp(unknown_c_data_packet, lexmark_device->transfer_buffer, unknown_c_data_packet_size) == 0){
+    return SANE_STATUS_GOOD;
+  }
+  if (memcmp(unknown_d_data_packet, lexmark_device->transfer_buffer, unknown_d_data_packet_size) == 0){
+    return SANE_STATUS_GOOD;
+  }
+  if (memcmp(unknown_e_data_packet, lexmark_device->transfer_buffer, unknown_e_data_packet_size) == 0){
+    return SANE_STATUS_GOOD;
+  }
+
+  status = clean_and_copy_data(
+      lexmark_device->transfer_buffer,
+      size,
+      data,
+      length,
+      lexmark_device->params.format,
+      max_length,
+      handle);
+
+  return status;
+}
+
+SANE_Status
+sane_set_io_mode (SANE_Handle handle, SANE_Bool non_blocking)
+{
+  DBG (2, "sane_set_io_mode: handle = %p, non_blocking = %d\n",
+       (void *) handle, non_blocking);
+
+  if (non_blocking)
+    return SANE_STATUS_UNSUPPORTED;
+
+  return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+sane_get_select_fd (SANE_Handle handle, SANE_Int * fd)
+{
+  DBG (2, "sane_get_select_fd: handle = %p, fd %s 0\n", (void *) handle,
+       fd ? "!=" : "=");
+
+  return SANE_STATUS_UNSUPPORTED;
+}
+
+void
+sane_cancel (SANE_Handle handle)
+{
+  Lexmark_Device * lexmark_device;
+
+  DBG (2, "sane_cancel: handle = %p\n", (void *) handle);
+
+  for (lexmark_device = first_device; lexmark_device;
+       lexmark_device = lexmark_device->next)
+    {
+      if (lexmark_device == handle)
+    break;
+    }
+  sanei_usb_reset (lexmark_device->devnum);
+  lexmark_device->device_cancelled = SANE_TRUE;
+}
+
+void
+sane_close (SANE_Handle handle)
+{
+  Lexmark_Device * lexmark_device;
+
+  DBG (2, "sane_close: handle=%p\n", (void *) handle);
+
+  for (lexmark_device = first_device; lexmark_device;
+       lexmark_device = lexmark_device->next)
+    {
+      if (lexmark_device == handle)
+    break;
+    }
+
+  sanei_usb_close (lexmark_device->devnum);
+}
+
+void
+sane_exit (void)
+{
+  Lexmark_Device *lexmark_device, *next_lexmark_device;
+
+  DBG (2, "sane_exit\n");
+
+  if (!initialized)
+    return;
+
+  for (lexmark_device = first_device; lexmark_device;
+       lexmark_device = next_lexmark_device)
+    {
+      next_lexmark_device = lexmark_device->next;
+      free (lexmark_device->transfer_buffer);
+      free (lexmark_device->read_buffer);
+      free (lexmark_device);
+    }
+
+  if (devlist)
+    free (devlist);
+
+  sanei_usb_exit();
+  initialized = SANE_FALSE;
+
+}