/* sane - Scanner Access Now Easy. Copyright (C) 2008 - 2008 Gerard Klaver Paul Wise The teco2 and gl646 backend (Frank Zago) are used as a template for this backend 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. */ /* $Id: lexmark2.c,v 1.4 2008/07/17 17:57:55 gerard Exp $ Lexmark2 backend Gerard Klaver/Paul Wise start 02-07-2008 update 12-07-2008 */ /*SANE FLOW DIAGRAM - sane_init() : initialize backend, attach scanners . - 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_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 BACKEND USB locking policy (lend from the rts8891 backend) - interface is released at the end of sane_open() to allow multiple usage by fronteds - if free, interface is claimed at sane_start(), and held until sane_cancel() is called - if free interface is claimed then released just during the access to buttons registers */ /*--------------------------------------------------------------------------*/ #define BUILD 1 #define BACKEND_NAME lexmark2 #define LEXMARK2_CONFIG_FILE "lexmark2.conf" /* --------------------- SANE INTERNATIONALISATION ------------------------ */ /* must be first include */ #include "../include/sane/config.h" #include #include #include #include #include #include #include #include #include #include #include #include "../include/sane/sane.h" #include "../include/sane/sanei.h" #include "../include/sane/saneopts.h" #include "../include/sane/sanei_usb.h" #include "../include/sane/sanei_debug.h" #include "../include/sane/sanei_backend.h" #include "../include/sane/sanei_config.h" #include "../include/lassert.h" #include "lexmark2.h" #define TIMEOUT 1000 /*--------------------------------------------------------------------------*/ /* Lists of possible scan modes. */ static SANE_String_Const scan_mode_list[] = { SANE_VALUE_SCAN_MODE_LINEART, SANE_VALUE_SCAN_MODE_GRAY, SANE_VALUE_SCAN_MODE_COLOR, NULL }; /* List of color dropout. */ static SANE_String_Const filter_color_list[] = { "Red", "Green", "Blue", NULL }; static const int filter_color_val[] = { 0, 1, 2 }; /*--------------------------------------------------------------------------*/ /* List of dithering options. */ static SANE_String_Const dither_list[] = { "Line art", "2x2", "3x3", "4x4 bayer", "4x4 smooth", "8x8 bayer", "8x8 smooth", "8x8 horizontal", "8x8 vertical", NULL }; static const int dither_val[] = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 }; /*-----------------------------------------minium, maximum, quantization----*/ static const SANE_Range brightness_range = { 0, 255, 1 }; static const SANE_Range contrast_range = { 0, 255, 1 }; static const SANE_Range threshold_range = { 0, 255, 0 }; static const SANE_Range black_level_range = { 0, 255, 1 }; static const SANE_Range red_level_range = { 0, 64, 1 }; static const SANE_Range green_level_range = { 0, 64, 1 }; static const SANE_Range blue_level_range = { 0, 64, 1 }; /*--------------------------------------------------------------------------*/ static const struct dpi_color_adjust lexmark2_dpi_color_adjust[] = { /*dpi, y, x, color sequence R G or B, 0 (-) or 1 (+) color skewing, lines skewing */ {75, 75, 1, 0, 2, 1, 2}, {100, 100, 1, 0, 2, 1, 2}, {150, 150, 1, 0, 2, 1, 2}, {200, 200, 1, 0, 2, 1, 2}, {300, 300, 1, 0, 2, 1, 2}, {600, 600, 1, 0, 2, 1, 2}, /* must be the last entry */ {0, 0, 0, 0, 0, 0, 0} }; /* For all scanners. apear in the c and lexmark2_dpi_color_adjust list. */ #define DEF_RESOLUTION 150 static const struct scanner_hardware scanners[] = { {0x043d, 0x00bb, USB_CLASS_VENDOR_SPEC, "LEXMARK", "X2330", {1, 600, 1}, /* resolution */ 600, 600, /* max x and Y resolution */ 2550, 12, 3, 0, /* calibration */ {SANE_FIX (0), SANE_FIX (8.5 * MM_PER_INCH), 0}, {SANE_FIX (0), SANE_FIX (11.7 * MM_PER_INCH), 0}, lexmark2_dpi_color_adjust}, {0x413c, 0x5118, USB_CLASS_VENDOR_SPEC, "Dell", "A810", {1, 600, 1}, /* resolution */ 600, 600, /* max x and Y resolution */ 2550, 12, 3, 0, /* calibration */ {SANE_FIX (0), SANE_FIX (8.5 * MM_PER_INCH), 0}, {SANE_FIX (0), SANE_FIX (11.7 * MM_PER_INCH), 0}, lexmark2_dpi_color_adjust} }; /* List of scanners attached. */ static Lexmark2_Scanner *first_dev = NULL; static int num_devices = 0; /* used by sane_get_devices */ static const SANE_Device **devlist = NULL; /*----------------------------------------------------------- */ /* Local functions. */ /* Display a buffer in the log. Display by lines of 16 bytes. */ static void hexdump (int level, const char *comment, unsigned char *buf, const int length) { int i; char line[128]; char *ptr; char asc_buf[17]; char *asc_ptr; DBG (level, " %s\n", comment); i = 0; goto start; do { if (i < length) { ptr += sprintf (ptr, " %2.2x", *buf); if (*buf >= 32 && *buf <= 127) { asc_ptr += sprintf (asc_ptr, "%c", *buf); } else { asc_ptr += sprintf (asc_ptr, "."); } } else { /* After the length; do nothing. */ ptr += sprintf (ptr, " "); } i++; buf++; if ((i % 16) == 0) { /* It's a new line */ DBG (level, " %s %s\n", line, asc_buf); start: ptr = line; *ptr = '\0'; asc_ptr = asc_buf; *asc_ptr = '\0'; ptr += sprintf (ptr, " %3.3d:", i); } } while (i < ((length + 15) & ~15)); } /* Returns the length of the longest string, including the terminating * character. */ static size_t max_string_size (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; } /* Lookup a string list from one array and return its index. */ static int get_string_list_index (SANE_String_Const list[], SANE_String_Const name) { int index; index = 0; while (list[index] != NULL) { if (strcmp (list[index], name) == 0) { return (index); } index++; } DBG (DBG_error, "name %s not found in list\n", name); assert (0); /* bug in backend, core dump */ return (-1); } /* Initialize a scanner entry. Return an allocated scanner with some * */ static Lexmark2_Scanner * lexmark2_init (void) { Lexmark2_Scanner *dev; DBG (DBG_proc, "lexmark2_init: enter\n"); /* Allocate a new scanner entry. */ dev = malloc (sizeof (Lexmark2_Scanner)); if (dev == NULL) { return NULL; } memset (dev, 0, sizeof (Lexmark2_Scanner)); /* Allocate the buffer used to transfer the USB data */ dev->buffer_size = 256 * 1024; dev->buffer = malloc (dev->buffer_size); if (dev->buffer == NULL) { free (dev); return NULL; } /* Allocate the windoww buffer*/ dev->windoww_size = 0x40; dev->windoww = malloc (dev->windoww_size); if (dev->windoww == NULL) { free (dev); free (dev->buffer); return NULL; } /* Allocate the windowr buffer*/ dev->windowr_size = 0x100; dev->windowr = malloc (dev->windowr_size); if (dev->windowr == NULL) { free (dev); free (dev->buffer); free (dev->windoww); return NULL; } dev->fd = -1; DBG (DBG_proc, "lexmark2_init: exit\n"); return (dev); } static SANE_Status lexmark2_set_config (Lexmark2_Scanner * dev, int configuration, int interface, int alternate) { SANE_Status status; DBG (DBG_proc, "lexmark2_set_config: open\n"); /* seems a problem on some systems (Debian amd64 unstable 19042006) * not calling usb_set_configuration seems to help reason ? */ /* status = sanei_usb_set_configuration (dev->fd, configuration); if (status != SANE_STATUS_GOOD) { DBG (DBG_error, "lexmark2_set_config: LEXMARK2 FAILED to set configuration %d\n", configuration); return status; } */ status = sanei_usb_claim_interface (dev->fd, interface); if (status != SANE_STATUS_GOOD) { DBG (DBG_error, "lexmark2_set_config: LEXMARK2 FAILED to claim interface\n"); return status; } status = sanei_usb_set_altinterface (dev->fd, alternate); if (status != SANE_STATUS_GOOD) { DBG (DBG_error, "lexmark2_set_config: LEXMARK2 FAILED to set alternate interface %d\n", alternate); return status; } DBG (DBG_proc, "lexmark2_set_config: configuration=%d, interface=%d, alternate=%d\n", configuration, interface, alternate); DBG (DBG_proc, "lexmark2_set_config: exit\n"); return status; } /* Closes an open scanners. */ static void lexmark2_close (Lexmark2_Scanner * dev) { DBG (DBG_proc, "lexmark2_close: enter \n"); if (dev->fd != -1) { sanei_usb_close (dev->fd); dev->fd = -1; } DBG (DBG_proc, "lexmark2_close: exit\n"); } /* Frees the memory used by a scanner. */ static void lexmark2_free (Lexmark2_Scanner * dev) { int i; DBG (DBG_proc, "lexmark2_free: enter\n"); if (dev == NULL) return; lexmark2_close (dev); if (dev->devicename) { free (dev->devicename); } if (dev->buffer) { free (dev->buffer); } if (dev->windoww) { free (dev->windoww); } if (dev->windowr) { free (dev->windowr); } for (i = 1; i < OPT_NUM_OPTIONS; i++) { if (dev->opt[i].type == SANE_TYPE_STRING && dev->val[i].s) { free (dev->val[i].s); } } if (dev->resolutions_list) free (dev->resolutions_list); free (dev); DBG (DBG_proc, "lexmark2_free: exit\n"); } /* Set a window. */ static SANE_Status lexmark2_set_window (Lexmark2_Scanner * dev) { size_t size; /* significant size of window */ unsigned char window[56]; SANE_Status status; int i; DBG (DBG_proc, "lexmark2_set_window: enter\n"); /* size of the whole windows block */ size = 0; /* keep gcc quiet */ size = 56; /* Check that window is big enough */ assert (size <= sizeof (window)); memset (window, 0, size); /* size of the windows descriptor block */ window[7] = size - 8; /* X and Y resolution */ Ito16 (dev->x_resolution, &window[10]); Ito16 (dev->y_resolution, &window[12]); /* Upper Left (X,Y) */ Ito32 (dev->x_tl, &window[14]); Ito32 (dev->y_tl, &window[18]); /* Width and length */ Ito32 (dev->width, &window[22]); Ito32 (dev->length, &window[26]); /* Image Composition */ switch (dev->scan_mode) { case LEXMARK2_LINEART: window[31] = dev->val[OPT_THRESHOLD].w; window[33] = 0x00; i = get_string_list_index (dither_list, dev->val[OPT_DITHER].s); window[36] = dither_val[i]; break; case LEXMARK2_GRAY: window[33] = 0x02; break; case LEXMARK2_COLOR: window[33] = 0x05; break; } /* Depth */ window[34] = dev->depth; /* Lamp to use */ i = get_string_list_index (filter_color_list, dev->val[OPT_FILTER_COLOR].s); window[48] = filter_color_val[i]; /* Unknown - invariants */ window[31] = 0x80; window[37] = 0x80; hexdump (DBG_info2, "windows", window, size); status = SANE_STATUS_GOOD; DBG (DBG_proc, "lexmark2_set_window: exit, status=%d\n", status); return status; } /* Reset scanner */ static SANE_Status lexmark2_reset_scanner (Lexmark2_Scanner * dev) { SANE_Status status; DBG (DBG_proc, "lexmark2_reset_scanner: enter\n"); status = SANE_STATUS_GOOD; DBG (DBG_proc, "lexmark2_reset_scanner: exit, status=%d\n", status); return status; } /* Read the size of the scan, for scanner ? */ static SANE_Status lexmark2_get_scan_size (Lexmark2_Scanner * dev) { SANE_Status status; DBG (DBG_proc, "lexmark2_get_scan_size: enter\n"); /* hexdump (DBG_info2, "lexmark2_get_scan_size return", dev->buffer, size); */ dev->params.lines = 150 * 11; dev->bytes_per_raster = 150 * 11 * 1; switch (dev->scan_mode) { case LEXMARK2_LINEART: dev->params.bytes_per_line = (150 * 8.5) / 8; dev->params.pixels_per_line = 150 * 8.5; break; case LEXMARK2_GRAY: dev->params.pixels_per_line = 75 * 17 * 1; dev->params.bytes_per_line = dev->params.bytes_per_line; break; case LEXMARK2_COLOR: if (dev->windoww) dev->params.pixels_per_line = 75 * 17 * 1; dev->params.bytes_per_line = dev->params.pixels_per_line * 3; break; } DBG (DBG_proc, "lexmark2_get_scan_size: , param.bytes_per_line =0x%x\n", dev->params.bytes_per_line); status = SANE_STATUS_GOOD; /* no correct test yet */ DBG (DBG_proc, "lexmark2_get_scan_size: exit, status=%d\n", status); return (status); } /* Start a scan. */ static SANE_Status lexmark2_scan (Lexmark2_Scanner * dev) { SANE_Status status; DBG (DBG_proc, "lexmark2_scan: enter\n"); /* no command yet placed */ status = SANE_STATUS_GOOD; DBG (DBG_proc, "lexmark2_scan: exit, status=%d\n", status); return status; } /* Inquiry a device and returns TRUE if is supported. */ static int lexmark2_identify_scanner (Lexmark2_Scanner * dev) { SANE_Status status; SANE_Word vendor; SANE_Word product; int i; DBG (DBG_info, "lexmark2_identify_scanner: open\n"); status = sanei_usb_get_vendor_product (dev->fd, &vendor, &product); /* Loop through our list to make sure this scanner is supported. */ for (i = 0; i < NELEMS (scanners); i++) { if (scanners[i].vendor == vendor && scanners[i].product == product) { DBG (DBG_info, "lexmark2_identify_scanner: scanner %x:%x is in list\n", vendor, product); dev->hw = &(scanners[i]); status = 1; if (status == 0) { DBG (DBG_error, "lexmark2_identify_scanner: this is not a supported device (idVendor = %d, bProduct = %d) writing register failed with %s\n", vendor, product, sane_strstatus (status)); return SANE_FALSE; } return SANE_TRUE; } } DBG (DBG_error, "lexmark2_identify_scanner: this is not a LEXMARK2) exit\n"); return SANE_FALSE; } typedef unsigned char BYTE; typedef unsigned short WORD; #define M_PER_IN 0.0254 #define LM_PACKET_LENGTH 8 #define LM_LINES_PER_READ 16 /* Magic byte at the start of each packet */ #define LM_MAGIC '\x1b' /* Packet type */ #define LM_CONTROL 'S' #define LM_DATA 's' #define LM_D 'D' /* Packet sub-type */ #define LM_CONTROL_RESET 'F' #define LM_CONTROL_STATUS 'S' #define LM_CONTROL_COLOUR 'C' #define LM_CONTROL_ORIGIN 'O' #define LM_CONTROL_SIZE 'Z' #define LM_CONTROL_DPI 'D' #define LM_CONTROL_GO 'G' #define LM_CONTROL_ABORT 'A' #define LM_CONTROL_I 'I' #define LM_CONTROL_V 'V' #define LM_D_S 'S' #define LM_D_S_L 'L' #define LM_D_S_U 'U' #define LM_DATA_DATA 'd' #define LM_DATA_v 'v' #define LM_STATUS_SUCCESS 0 #define LM_STATUS_FAILURE 2 static int lmX2330_write (Lexmark2_Scanner * dev, BYTE packet_type, BYTE packet_subtype, BYTE p1, BYTE p2, BYTE p3, BYTE p4, BYTE p5) { int r; size_t size; SANE_Byte buf[LM_PACKET_LENGTH]; buf[0] = LM_MAGIC; buf[1] = packet_type; buf[2] = packet_subtype; buf[3] = p1; buf[4] = p2; buf[5] = p3; buf[6] = p4; buf[7] = p5; DBG (DBG_info, "lexmark2 lmX2330_write: open\n"); /* r = usb_bulk_write(devh, 0x6, buf, sizeof(buf), 1000); */ size = sizeof (buf); r = sanei_usb_write_bulk (dev->fd, buf, &size); DBG (DBG_info, "write %c%c: %d\n", packet_type, packet_subtype, r); if (r < 0) printf ("error: write %c%c failed: %d\n", packet_type, packet_subtype, r); if (r >= 0 && r != sizeof (buf)) printf ("error: write %c%c different: %d\n", packet_type, packet_subtype, r); DBG (DBG_info, "lexmark2 lmX2330_write: exit\n"); return r; } static int lmX2330_read (Lexmark2_Scanner * dev, BYTE packet_type, BYTE packet_subtype, SANE_Byte * buf, size_t buf_len) { int r; DBG (DBG_info, "lexmark2 lmX2330_read: open\n"); assert (buf_len >= LM_PACKET_LENGTH); /* r = usb_bulk_read(devh, 0x83, buf, buf_len, delay); */ r = sanei_usb_read_bulk (dev->fd, buf, &buf_len); DBG (DBG_info, "read %c%c %d, actually read %c%c %d\n", packet_type, packet_subtype, buf_len, buf[1], buf[2], r); if (r < 0) DBG (DBG_error, "error: read %c%c failed: %d\n", packet_type, packet_subtype, r); if (r >= 0 && r != buf_len && r != LM_PACKET_LENGTH) DBG (DBG_error, "error: read %c%c different: %d\n", packet_type, packet_subtype, r); if (r >= 0 && buf[0] != LM_MAGIC) DBG (DBG_warning, "warning: found packet %c%c with wrong magic: 0x%2.2x\n", packet_type, packet_subtype, buf[0]); if (r >= 0 && buf[1] != packet_type) DBG (DBG_warning, "warning: found packet %c%c with wrong type: 0x%2.2x\n", packet_type, packet_subtype, buf[1]); if (r >= 0 && buf[2] != packet_subtype) DBG (DBG_warning, "warning: found packet %c%c with wrong subtype: 0x%2.2hhx\n", packet_type, packet_subtype, buf[2]); DBG (DBG_info, "lexmark2 lmX2330_read: exit\n"); return r; } static void lmX2330_reset (Lexmark2_Scanner * dev) { lmX2330_write (dev, LM_CONTROL, LM_CONTROL_RESET, 0, 0, 0, 0, 0); } static void lmX2330_d_s_l (Lexmark2_Scanner * dev) { lmX2330_write (dev, LM_D, LM_D_S, LM_D_S_L, 0, 0, 0, 0); } /* to do change colour to ... mode, add colour_mode instead of 3 or 1 */ static void lmX2330_colour (Lexmark2_Scanner * dev) { lmX2330_write (dev, LM_CONTROL, LM_CONTROL_COLOUR, 3, 8, 0, 0, 0x50); } static void lmX2330_greyscale (Lexmark2_Scanner * dev) { lmX2330_write (dev, LM_CONTROL, LM_CONTROL_COLOUR, 1, 8, 0, 0, 0x50); } static void lmX2330_control_i (Lexmark2_Scanner * dev, int cp) { lmX2330_write (dev, LM_CONTROL, LM_CONTROL_I, 0, 0, 0, cp ? 0x78 : 0x02, 0); } static void lmX2330_resolution (Lexmark2_Scanner * dev, WORD x, WORD y) { assert (x == y); lmX2330_write (dev, LM_CONTROL, LM_CONTROL_DPI, (BYTE) x, (BYTE) (x >> 8), (BYTE) y, (BYTE) (y >> 8), 0); } static void lmX2330_origin (Lexmark2_Scanner * dev, WORD x, WORD y) { lmX2330_write (dev, LM_CONTROL, LM_CONTROL_ORIGIN, (BYTE) x, (BYTE) (x >> 8), (BYTE) y, (BYTE) (y >> 8), 0); } static void lmX2330_size (Lexmark2_Scanner * dev, WORD x, WORD y) { lmX2330_write (dev, LM_CONTROL, LM_CONTROL_SIZE, (BYTE) x, (BYTE) (x >> 8), (BYTE) y, (BYTE) (y >> 8), 0); } static void lmX2330_go (Lexmark2_Scanner * dev) { lmX2330_write (dev, LM_CONTROL, LM_CONTROL_GO, 0, 0, 0, 0, 0); } static void lmX2330_d_s_u (Lexmark2_Scanner * dev) { lmX2330_write (dev, LM_D, LM_D_S, LM_D_S_U, 0, 0, 0, 0); } static void lmX2330_abort (Lexmark2_Scanner * dev) { lmX2330_write (dev, LM_CONTROL, LM_CONTROL_ABORT, 0, 0, 0, 0, 0); } static void lmX2330_status (Lexmark2_Scanner * dev) { BYTE buf[0x40]; int r = lmX2330_read (dev, LM_CONTROL, LM_CONTROL_STATUS, buf, sizeof (buf)); /* to do hh warnings */ if (r >= 0 && buf[3] != 0) DBG (DBG_warning, "warning: found %c%c packet with different param 3: 0x%2.2hhx\n", buf[1], buf[2], buf[3]); if (r >= 0 && buf[4] != 0) DBG (DBG_warning, "warning: found %c%c packet with different param 4: 0x%2.2hhx\n", buf[1], buf[2], buf[4]); if (r >= 0 && buf[5] != 0) DBG (DBG_warning, "warning: found %c%c packet with different param 5: 0x%2.2hhx\n", buf[1], buf[2], buf[5]); if (r >= 0 && buf[6] != 0) DBG (DBG_warning, "warning: found %c%c packet with different param 6: 0x%2.2hhx\n", buf[1], buf[2], buf[6]); if (r >= 0 && buf[7] != 0) DBG (DBG_warning, "warning: found %c%c packet with different param 7: 0x%2.2hhx\n", buf[1], buf[2], buf[7]); if (buf[1] == LM_CONTROL && buf[2] == LM_CONTROL_STATUS && buf[3] == LM_STATUS_SUCCESS) { DBG (DBG_info, "yay!\n"); } if (buf[1] == LM_CONTROL && buf[2] == LM_CONTROL_STATUS && buf[3] == LM_STATUS_FAILURE) { DBG (DBG_error, "FAIL!\n"); exit (1); } DBG (DBG_info, "lexmark2 lmX2330_status: exit\n"); } static SANE_Status lexmark2_scanner_init (Lexmark2_Scanner * dev) { SANE_Status status; int delay; size_t sizew; size_t sizer; size_t size; int colour = 1; int res_x = dev->x_resolution; int res_y = dev->x_resolution; int size_x = 1275; int size_y = 1755; int origin_x = 0; int origin_y = 0; int r = 0; BYTE buf[0x10000]; DBG (DBG_proc, "lexmark2_scanner_init: open\n"); sizew = dev->windoww_size; sizer = dev->windowr_size; memset (dev->windoww, 0, sizew); memset (dev->windowr, 0, sizer); /* some time delay or check needed */ delay = 5000; usleep (delay); DBG (DBG_proc, "lexmark2_scanner_init: usb port already open?\n"); /* signal(SIGTERM, release_usb_device); */ /* size = sizeof (buf); r = usb_get_driver_np (dev->fd, 0, buf, &size); printf ("usb_get_driver_np returned %d\n", r); if (r == 0) { printf ("interface 0 already claimed by driver \"%s\", attempting to detach it\n", buf); r = usb_detach_kernel_driver_np (dev->fd, 0); printf ("usb_detach_kernel_driver_np returned %d\n", r); } */ lmX2330_reset (dev); /* configuration = 0, interface = 0, alternate = 0 */ status = lexmark2_set_config (dev, 0, 0, 0); if (status != SANE_STATUS_GOOD) { DBG (DBG_error, "lexmark2_reset_scanner: LEXMARK2 FAILED to set configure, interface, alternate\n"); return status; } lmX2330_status (dev); lmX2330_d_s_l (dev); lmX2330_status (dev); switch (dev->scan_mode) { case LEXMARK2_LINEART: colour = 0; break; case LEXMARK2_GRAY: colour = 0; break; case LEXMARK2_COLOR: colour = 1; break; } if (colour) lmX2330_colour (dev); else lmX2330_greyscale (dev); lmX2330_status (dev); lmX2330_control_i (dev, 1); lmX2330_status (dev); lmX2330_resolution (dev, res_x, res_y); lmX2330_status (dev); lmX2330_origin (dev, origin_x, origin_y); lmX2330_status (dev); lmX2330_size (dev, size_x, size_y); lmX2330_status (dev); lmX2330_go (dev); status = SANE_STATUS_GOOD; /* to do update status */ DBG (DBG_proc, "lexmark2_scanner_init: exit\n"); return status; } /* Attach a scanner to this backend. */ static SANE_Status attach_scanner (SANE_String_Const devicename, Lexmark2_Scanner ** devp) { Lexmark2_Scanner *dev; int fd; SANE_Status status; DBG (DBG_info, "attach_scanner: %s\n", devicename); if (devp) *devp = NULL; /* Check if we know this device name. */ for (dev = first_dev; dev; dev = dev->next) { if (strcmp (dev->sane.name, devicename) == 0) { if (devp) { *devp = dev; } DBG (DBG_info, "device is already known\n"); return SANE_STATUS_GOOD; } } /* Allocate a new scanner entry. */ dev = lexmark2_init (); if (dev == NULL) { DBG (DBG_error, "ERROR: not enough memory\n"); return SANE_STATUS_NO_MEM; } DBG (DBG_info, "attach_scanner: opening USB device %s\n", devicename); if (sanei_usb_open (devicename, &fd) != 0) { DBG (DBG_error, "ERROR: attach_scanner: open failed\n"); lexmark2_free (dev); return SANE_STATUS_INVAL; } /* Fill some scanner specific values. */ dev->devicename = strdup (devicename); dev->fd = fd; /* Now, check that it is a scanner we support. */ if (lexmark2_identify_scanner (dev) == SANE_FALSE) { DBG (DBG_error, "ERROR: attach_scanner: scanner-identification failed\n"); lexmark2_free (dev); return SANE_STATUS_INVAL; } lexmark2_close (dev); /* Build list of scanner supported resolutions. */ DBG (DBG_proc, "attach_scanner: build resolution list\n"); if (dev->hw->color_adjust[0].resolution_x != 0) { int num_entries; int i; num_entries = 0; while (dev->hw->color_adjust[num_entries].resolution_x != 0) num_entries++; dev->resolutions_list = malloc (sizeof (SANE_Word) * (num_entries + 1)); if (dev->resolutions_list == NULL) { DBG (DBG_error, "ERROR: attach_scanner: scanner resolution list failed\n"); lexmark2_free (dev); return SANE_STATUS_NO_MEM; } dev->resolutions_list[0] = num_entries; DBG (DBG_proc, "attach_scanner: make color resolution table \n"); for (i = 0; i < num_entries; i++) { dev->resolutions_list[i + 1] = dev->hw->color_adjust[i].resolution_x; } } else { dev->resolutions_list = NULL; } DBG (DBG_proc, "attach_scanner: build resolution list after list build\n"); /* Set the default options for that scanner. */ dev->sane.name = dev->devicename; dev->sane.vendor = dev->hw->vendor_name; dev->sane.model = dev->hw->product_name; dev->sane.type = SANE_I18N ("scanner"); /* Link the scanner with the others. */ dev->next = first_dev; first_dev = dev; if (devp) { *devp = dev; } num_devices++; DBG (DBG_proc, "attach_scanner: exit\n"); status = SANE_STATUS_GOOD; /* to do update */ return status; } static SANE_Status attach_one (const char *dev) { DBG (DBG_proc, "attach_one: open \n"); attach_scanner (dev, NULL); DBG (DBG_proc, "attach_one: exit \n"); return SANE_STATUS_GOOD; } /* Reset the options for that scanner. */ static void lexmark2_init_options (Lexmark2_Scanner * dev) { int i; DBG (DBG_proc, "lexmark2_init_options: open\n"); /* Pre-initialize the options. */ memset (dev->opt, 0, sizeof (dev->opt)); memset (dev->val, 0, sizeof (dev->val)); for (i = 0; i < OPT_NUM_OPTIONS; ++i) { dev->opt[i].size = sizeof (SANE_Word); dev->opt[i].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT; } DBG (DBG_proc, "lexmark2_init_options: done loop opt_num_options=%d, i=%d \n", OPT_NUM_OPTIONS, i); /* Number of options. */ dev->opt[OPT_NUM_OPTS].name = ""; dev->opt[OPT_NUM_OPTS].title = SANE_TITLE_NUM_OPTIONS; dev->opt[OPT_NUM_OPTS].desc = SANE_DESC_NUM_OPTIONS; dev->opt[OPT_NUM_OPTS].type = SANE_TYPE_INT; dev->opt[OPT_NUM_OPTS].cap = SANE_CAP_SOFT_DETECT; dev->val[OPT_NUM_OPTS].w = OPT_NUM_OPTIONS; /* Mode group */ dev->opt[OPT_MODE_GROUP].title = SANE_I18N ("Scan Mode"); dev->opt[OPT_MODE_GROUP].desc = ""; /* not valid for a group */ dev->opt[OPT_MODE_GROUP].type = SANE_TYPE_GROUP; dev->opt[OPT_MODE_GROUP].cap = 0; dev->opt[OPT_MODE_GROUP].size = 0; dev->opt[OPT_MODE_GROUP].constraint_type = SANE_CONSTRAINT_NONE; /* Scanner supported modes */ dev->opt[OPT_MODE].name = SANE_NAME_SCAN_MODE; dev->opt[OPT_MODE].title = SANE_TITLE_SCAN_MODE; dev->opt[OPT_MODE].desc = SANE_DESC_SCAN_MODE; dev->opt[OPT_MODE].type = SANE_TYPE_STRING; dev->opt[OPT_MODE].size = max_string_size (scan_mode_list); dev->opt[OPT_MODE].constraint_type = SANE_CONSTRAINT_STRING_LIST; dev->opt[OPT_MODE].constraint.string_list = scan_mode_list; dev->val[OPT_MODE].s = (SANE_Char *) strdup (""); /* will be set later */ /* X and Y resolution */ dev->opt[OPT_RESOLUTION].name = SANE_NAME_SCAN_RESOLUTION; dev->opt[OPT_RESOLUTION].title = SANE_TITLE_SCAN_RESOLUTION; dev->opt[OPT_RESOLUTION].desc = SANE_DESC_SCAN_RESOLUTION; dev->opt[OPT_RESOLUTION].type = SANE_TYPE_INT; dev->opt[OPT_RESOLUTION].unit = SANE_UNIT_DPI; dev->opt[OPT_RESOLUTION].constraint_type = SANE_CONSTRAINT_RANGE; dev->val[OPT_RESOLUTION].w = DEF_RESOLUTION; /* Geometry group */ dev->opt[OPT_GEOMETRY_GROUP].title = SANE_I18N ("Geometry"); dev->opt[OPT_GEOMETRY_GROUP].desc = ""; /* not valid for a group */ dev->opt[OPT_GEOMETRY_GROUP].type = SANE_TYPE_GROUP; dev->opt[OPT_GEOMETRY_GROUP].cap = 0; dev->opt[OPT_GEOMETRY_GROUP].size = 0; dev->opt[OPT_GEOMETRY_GROUP].constraint_type = SANE_CONSTRAINT_NONE; /* Upper left X */ dev->opt[OPT_TL_X].name = SANE_NAME_SCAN_TL_X; dev->opt[OPT_TL_X].title = SANE_TITLE_SCAN_TL_X; dev->opt[OPT_TL_X].desc = SANE_DESC_SCAN_TL_X; dev->opt[OPT_TL_X].type = SANE_TYPE_FIXED; dev->opt[OPT_TL_X].unit = SANE_UNIT_MM; dev->opt[OPT_TL_X].constraint_type = SANE_CONSTRAINT_RANGE; dev->opt[OPT_TL_X].constraint.range = &dev->hw->x_range; dev->val[OPT_TL_X].w = dev->hw->x_range.min; /* Upper left Y */ dev->opt[OPT_TL_Y].name = SANE_NAME_SCAN_TL_Y; dev->opt[OPT_TL_Y].title = SANE_TITLE_SCAN_TL_Y; dev->opt[OPT_TL_Y].desc = SANE_DESC_SCAN_TL_Y; dev->opt[OPT_TL_Y].type = SANE_TYPE_FIXED; dev->opt[OPT_TL_Y].unit = SANE_UNIT_MM; dev->opt[OPT_TL_Y].constraint_type = SANE_CONSTRAINT_RANGE; dev->opt[OPT_TL_Y].constraint.range = &dev->hw->y_range; dev->val[OPT_TL_Y].w = dev->hw->y_range.min; /* Bottom-right x */ dev->opt[OPT_BR_X].name = SANE_NAME_SCAN_BR_X; dev->opt[OPT_BR_X].title = SANE_TITLE_SCAN_BR_X; dev->opt[OPT_BR_X].desc = SANE_DESC_SCAN_BR_X; dev->opt[OPT_BR_X].type = SANE_TYPE_FIXED; dev->opt[OPT_BR_X].unit = SANE_UNIT_MM; dev->opt[OPT_BR_X].constraint_type = SANE_CONSTRAINT_RANGE; dev->opt[OPT_BR_X].constraint.range = &dev->hw->x_range; dev->val[OPT_BR_X].w = dev->hw->x_range.max; /* Bottom-right y */ dev->opt[OPT_BR_Y].name = SANE_NAME_SCAN_BR_Y; dev->opt[OPT_BR_Y].title = SANE_TITLE_SCAN_BR_Y; dev->opt[OPT_BR_Y].desc = SANE_DESC_SCAN_BR_Y; dev->opt[OPT_BR_Y].type = SANE_TYPE_FIXED; dev->opt[OPT_BR_Y].unit = SANE_UNIT_MM; dev->opt[OPT_BR_Y].constraint_type = SANE_CONSTRAINT_RANGE; dev->opt[OPT_BR_Y].constraint.range = &dev->hw->y_range; dev->val[OPT_BR_Y].w = dev->hw->y_range.max; /* brightness */ dev->opt[OPT_BRIGHTNESS].name = SANE_NAME_BRIGHTNESS; dev->opt[OPT_BRIGHTNESS].title = SANE_TITLE_BRIGHTNESS; dev->opt[OPT_BRIGHTNESS].desc = SANE_DESC_BRIGHTNESS; dev->opt[OPT_BRIGHTNESS].type = SANE_TYPE_INT; dev->opt[OPT_BRIGHTNESS].unit = SANE_UNIT_NONE; dev->opt[OPT_BRIGHTNESS].constraint_type = SANE_CONSTRAINT_RANGE; dev->opt[OPT_BRIGHTNESS].constraint.range = &brightness_range; dev->val[OPT_BRIGHTNESS].w = 80; /* to get middle value */ /* contrast */ dev->opt[OPT_CONTRAST].name = SANE_NAME_CONTRAST; dev->opt[OPT_CONTRAST].title = SANE_TITLE_CONTRAST; dev->opt[OPT_CONTRAST].desc = SANE_DESC_CONTRAST; dev->opt[OPT_CONTRAST].type = SANE_TYPE_INT; dev->opt[OPT_CONTRAST].unit = SANE_UNIT_NONE; dev->opt[OPT_CONTRAST].constraint_type = SANE_CONSTRAINT_RANGE; dev->opt[OPT_CONTRAST].constraint.range = &contrast_range; dev->val[OPT_CONTRAST].w = 80; /* to get middle value */ /* Enhancement group */ dev->opt[OPT_ENHANCEMENT_GROUP].title = SANE_I18N ("Enhancement"); dev->opt[OPT_ENHANCEMENT_GROUP].desc = ""; /* not valid for a group */ dev->opt[OPT_ENHANCEMENT_GROUP].type = SANE_TYPE_GROUP; dev->opt[OPT_ENHANCEMENT_GROUP].cap = SANE_CAP_ADVANCED; dev->opt[OPT_ENHANCEMENT_GROUP].size = 0; dev->opt[OPT_ENHANCEMENT_GROUP].constraint_type = SANE_CONSTRAINT_NONE; /* Threshold */ dev->opt[OPT_THRESHOLD].name = SANE_NAME_THRESHOLD; dev->opt[OPT_THRESHOLD].title = SANE_TITLE_THRESHOLD; dev->opt[OPT_THRESHOLD].desc = SANE_DESC_THRESHOLD; dev->opt[OPT_THRESHOLD].type = SANE_TYPE_INT; dev->opt[OPT_THRESHOLD].unit = SANE_UNIT_NONE; dev->opt[OPT_THRESHOLD].size = sizeof (SANE_Int); dev->opt[OPT_THRESHOLD].cap |= SANE_CAP_INACTIVE; dev->opt[OPT_THRESHOLD].constraint_type = SANE_CONSTRAINT_RANGE; dev->opt[OPT_THRESHOLD].constraint.range = &threshold_range; dev->val[OPT_THRESHOLD].w = 128; /* Halftone pattern */ dev->opt[OPT_DITHER].name = "dither"; dev->opt[OPT_DITHER].title = SANE_I18N ("Dither"); dev->opt[OPT_DITHER].desc = SANE_I18N ("Dither"); dev->opt[OPT_DITHER].type = SANE_TYPE_STRING; dev->opt[OPT_DITHER].size = max_string_size (dither_list); dev->opt[OPT_DITHER].cap |= SANE_CAP_INACTIVE; dev->opt[OPT_DITHER].constraint_type = SANE_CONSTRAINT_STRING_LIST; dev->opt[OPT_DITHER].constraint.string_list = dither_list; dev->val[OPT_DITHER].s = strdup (dither_list[0]); /* Color filter */ dev->opt[OPT_FILTER_COLOR].name = "color-filter"; dev->opt[OPT_FILTER_COLOR].title = "Color dropout"; dev->opt[OPT_FILTER_COLOR].desc = "Color dropout"; dev->opt[OPT_FILTER_COLOR].type = SANE_TYPE_STRING; dev->opt[OPT_FILTER_COLOR].size = max_string_size (filter_color_list); dev->opt[OPT_FILTER_COLOR].cap |= SANE_CAP_INACTIVE; dev->opt[OPT_FILTER_COLOR].constraint_type = SANE_CONSTRAINT_STRING_LIST; dev->opt[OPT_FILTER_COLOR].constraint.string_list = filter_color_list; dev->val[OPT_FILTER_COLOR].s = (SANE_Char *) strdup (filter_color_list[0]); /* black level correction */ dev->opt[OPT_BLACK_LEVEL].name = SANE_NAME_BLACK_LEVEL; dev->opt[OPT_BLACK_LEVEL].title = SANE_TITLE_BLACK_LEVEL; dev->opt[OPT_BLACK_LEVEL].desc = SANE_DESC_BLACK_LEVEL; dev->opt[OPT_BLACK_LEVEL].type = SANE_TYPE_INT; dev->opt[OPT_BLACK_LEVEL].unit = SANE_UNIT_NONE; dev->opt[OPT_BLACK_LEVEL].constraint_type = SANE_CONSTRAINT_RANGE; dev->opt[OPT_BLACK_LEVEL].constraint.range = &black_level_range; dev->val[OPT_BLACK_LEVEL].w = 02; /* to get middle value */ /* red level calibration manual correction */ dev->opt[OPT_WHITE_LEVEL_R].name = SANE_NAME_WHITE_LEVEL_R; dev->opt[OPT_WHITE_LEVEL_R].title = SANE_TITLE_WHITE_LEVEL_R; dev->opt[OPT_WHITE_LEVEL_R].desc = SANE_DESC_WHITE_LEVEL_R; dev->opt[OPT_WHITE_LEVEL_R].type = SANE_TYPE_INT; dev->opt[OPT_WHITE_LEVEL_R].unit = SANE_UNIT_NONE; dev->opt[OPT_WHITE_LEVEL_R].constraint_type = SANE_CONSTRAINT_RANGE; dev->opt[OPT_WHITE_LEVEL_R].constraint.range = &red_level_range; dev->val[OPT_WHITE_LEVEL_R].w = 02; /* to get middle value */ /* green level calibration manual correction */ dev->opt[OPT_WHITE_LEVEL_G].name = SANE_NAME_WHITE_LEVEL_G; dev->opt[OPT_WHITE_LEVEL_G].title = SANE_TITLE_WHITE_LEVEL_G; dev->opt[OPT_WHITE_LEVEL_G].desc = SANE_DESC_WHITE_LEVEL_G; dev->opt[OPT_WHITE_LEVEL_G].type = SANE_TYPE_INT; dev->opt[OPT_WHITE_LEVEL_G].unit = SANE_UNIT_NONE; dev->opt[OPT_WHITE_LEVEL_G].constraint_type = SANE_CONSTRAINT_RANGE; dev->opt[OPT_WHITE_LEVEL_G].constraint.range = &green_level_range; dev->val[OPT_WHITE_LEVEL_G].w = 02; /* to get middle value */ /* blue level calibration manual correction */ dev->opt[OPT_WHITE_LEVEL_B].name = SANE_NAME_WHITE_LEVEL_B; dev->opt[OPT_WHITE_LEVEL_B].title = SANE_TITLE_WHITE_LEVEL_B; dev->opt[OPT_WHITE_LEVEL_B].desc = SANE_DESC_WHITE_LEVEL_B; dev->opt[OPT_WHITE_LEVEL_B].type = SANE_TYPE_INT; dev->opt[OPT_WHITE_LEVEL_B].unit = SANE_UNIT_NONE; dev->opt[OPT_WHITE_LEVEL_B].constraint_type = SANE_CONSTRAINT_RANGE; dev->opt[OPT_WHITE_LEVEL_B].constraint.range = &blue_level_range; dev->val[OPT_WHITE_LEVEL_B].w = 02; /* to get middle value */ /* preview */ dev->opt[OPT_PREVIEW].name = SANE_NAME_PREVIEW; dev->opt[OPT_PREVIEW].title = SANE_TITLE_PREVIEW; dev->opt[OPT_PREVIEW].desc = SANE_DESC_PREVIEW; dev->opt[OPT_PREVIEW].type = SANE_TYPE_BOOL; dev->opt[OPT_PREVIEW].cap = SANE_CAP_SOFT_DETECT | SANE_CAP_SOFT_SELECT; dev->val[OPT_PREVIEW].w = SANE_FALSE; /* Lastly, set the default scan mode. This might change some * values previously set here. */ sane_control_option (dev, OPT_MODE, SANE_ACTION_SET_VALUE, (SANE_String_Const *) scan_mode_list[0], NULL); DBG (DBG_proc, "lexmark2_init_options: exit\n"); } /* * Wait until the scanner is ready. */ static SANE_Status lexmark2_wait_scanner (Lexmark2_Scanner * dev) { SANE_Status status; int timeout; DBG (DBG_proc, "lexmark2_wait_scanner: enter\n"); /* Set the timeout to 60 seconds. */ timeout = 60; while (timeout > 0) { /* test unit ready */ /* status = sanei_scsi_cmd (dev->fd, cdb.data, cdb.len, NULL, NULL);*/ status = SANE_STATUS_GOOD; if (status == SANE_STATUS_GOOD) { DBG (DBG_proc, "lexmark2_wait_scanner: scanner status good\n"); return SANE_STATUS_GOOD; } sleep (1); }; DBG (DBG_proc, "lexmark2_wait_scanner: scanner not ready\n"); return (SANE_STATUS_IO_ERROR); } /* Read the image from the scanner and fill the temporary buffer with it. */ static SANE_Status lexmark2_fill_image (Lexmark2_Scanner * dev) { SANE_Status status; size_t size; int delay; size_t sizew; size_t sizer; int colour = 1; int res_x = dev->x_resolution; /*default 150 for x and y only supported */ int res_y = dev->y_resolution; /*int size_x = 1275; int size_y = 1755; */ int size_x = dev->width; /* default at the moment 1275 */ int size_y = dev->length; /* default at the moment 1755 */ int origin_x = 0; int origin_y = 0; int r = 0; int write = 1; int line, i; size_t bytes, line_len; BYTE buf[0x10000]; DBG (DBG_proc, "lexmark2_fill_image: enter\n"); assert (dev->image_begin == dev->image_end); assert (dev->real_bytes_left > 0); sizew = dev->windoww_size; sizer = dev->windowr_size; memset (dev->windoww, 0, sizew); memset (dev->windowr, 0, sizer); /* Copy the complete lines, plus the incompletes * ones. We don't keep the real end of data used * in image, so we copy the biggest possible. * * This is a no-op for non color images. */ memmove (dev->image, dev->image + dev->image_begin, dev->raster_ahead); dev->image_begin = 0; dev->image_end = 0; DBG (DBG_proc, "lexmark2_fill_image: real bytes left=0x%x \n", dev->real_bytes_left); /* Fill image, some setting for the scanner first */ /* some time delay or check needed */ delay = 2000; usleep (delay); do { /* Try to read the maximum number of bytes. */ DBG (DBG_proc, "lexmark2_fill_image: real dev bytes left, start while loop=0x%x \n", dev->real_bytes_left); size = dev->real_bytes_left; if (size > dev->buffer_size) { size = dev->buffer_size; DBG (DBG_proc, "lexmark2_fill_image: size > dev->buffer_size, size =0x%x \n", size); } if (size > 0x8000) { size = 0x8000; /* it seems package from printer < 8000/urb */ DBG (DBG_proc, "lexmark2_fill_image: size > 0x20000, size =0x%x \n", size); } /* Round down to a multiple of line size. */ /* size = size - (size % dev->params.bytes_per_line); */ if (size == 0) { /* Probably reached the end of the buffer. * Check, just in case. */ assert (dev->image_end != 0); return (SANE_STATUS_GOOD); } if (write) { lmX2330_reset (dev); lmX2330_status (dev); lmX2330_d_s_l (dev); lmX2330_status (dev); if (colour) lmX2330_colour (dev); else lmX2330_greyscale (dev); lmX2330_status (dev); lmX2330_control_i (dev, 1); lmX2330_status (dev); lmX2330_resolution (dev, res_x, res_y); lmX2330_status (dev); lmX2330_origin (dev, origin_x, origin_y); lmX2330_status (dev); lmX2330_size (dev, size_x, size_y); lmX2330_status (dev); lmX2330_go (dev); if (colour) { line_len = LM_PACKET_LENGTH + 3 * size_x; bytes = line_len * LM_LINES_PER_READ; } else { line_len = LM_PACKET_LENGTH + size_x; bytes = line_len * LM_LINES_PER_READ; } line = 0; usleep (1000 * 1000); while (1) { usleep (100 * 1000); r = lmX2330_read (dev, LM_DATA, LM_DATA_DATA, buf, bytes); printf ("line %d: r %d: \n", line, r); line += LM_LINES_PER_READ; for (i = 0; i < r; i += line_len) { /* png_write_row(png_ptr,&buf[i+LM_PACKET_LENGTH]); */ memcpy (dev->image + dev->image_end, buf, bytes); } if (r != bytes) { printf ("Read %d bytes (less than %d), exiting\n", r, bytes); break; } } lmX2330_status (dev); lmX2330_d_s_u (dev); lmX2330_status (dev); lmX2330_reset (dev); lmX2330_status (dev); } else { r = lmX2330_read (dev, LM_DATA, LM_DATA_DATA, buf, sizeof (buf)); printf ("extra read r %d: \n", r); } /* bulk read image */ /* DBG (DBG_proc, "lexmark2_fill_image: start read bulk to read size=0x%x, dev->real_bytes_left 0x%x\n", size, dev->real_bytes_left); status = sanei_usb_read_bulk (dev->fd, dev->buffer, &size); if (status != SANE_STATUS_GOOD) { DBG (DBG_error, "lexmark2_fill_image: cannot read from the scanner\n"); return status; } */ DBG (DBG_info, "lexmark2_fill_image: data read size=0x%lx bytes (bpl=0x%x)\n", (long) size, dev->params.bytes_per_line); memcpy (dev->image + dev->image_end, dev->buffer, size); dev->image_end += size; DBG (DBG_info, "lexmark2_fill_image: dev->image_end=0x%x bytes\n", dev->image_end); dev->real_bytes_left -= size; /* some time delay or check needed */ if (dev->real_bytes_left < size) { dev->real_bytes_left = 0; /* do only if size is small */ size = 0; dev->bytes_left = 0; DBG (DBG_proc, "lexmark2_fill_image, detect end of paper, scan can stop?, size =0\n"); } DBG (DBG_proc, "lexmark2_fill_image, next loop for scan lines\n"); } while (1); DBG (DBG_proc, "lexmark2_fill_image: exit\n"); status = SANE_STATUS_GOOD; return status; /* unreachable */ } /* Copy from the raw buffer to the buffer given by the backend. * * len in input is the maximum length available in buf, and, in * output, is the length written into buf. */ static void lexmark2_copy_raw_to_frontend (Lexmark2_Scanner * dev, SANE_Byte * buf, size_t * len) { size_t size; size = dev->image_end - dev->image_begin; if (size > *len) { size = *len; } *len = size; switch (dev->scan_mode) { case LEXMARK2_LINEART: { /* Invert black and white. */ unsigned char *src = dev->image + dev->image_begin; size_t i; for (i = 0; i < size; i++) { *buf = *src ^ 0xff; src++; buf++; } } break; case LEXMARK2_GRAY: case LEXMARK2_COLOR: memcpy (buf, dev->image + dev->image_begin, size); break; } dev->image_begin += size; } /*--------------------------------------------------------------------------*/ /* Sane entry points */ SANE_Status sane_init (SANE_Int * version_code, SANE_Auth_Callback authorize) { FILE *fp; char line[PATH_MAX]; size_t len; DBG_INIT (); DBG (DBG_sane_init, "sane_init\n"); authorize = authorize; /* silence gcc */ DBG (DBG_error, "This is sane-lexmark2 version %d.%d-%d\n", V_MAJOR, V_MINOR, BUILD); DBG (DBG_error, "(C) 2008-2008 by Gerard Klaver/Paul Wise\n"); if (version_code) { *version_code = SANE_VERSION_CODE (V_MAJOR, V_MINOR, BUILD); } sanei_usb_init (); fp = sanei_config_open (LEXMARK2_CONFIG_FILE); if (!fp) { /* No default scanner? */ DBG (DBG_warning, "configuration file not found (%s)\n", LEXMARK2_CONFIG_FILE); return SANE_STATUS_GOOD; } while (sanei_config_read (line, sizeof (line), fp)) { SANE_Word vendor; SANE_Word product; if (line[0] == '#') /* ignore line comments */ continue; len = strlen (line); if (!len) continue; /* ignore empty lines */ if (sscanf (line, "usb %i %i", &vendor, &product) == 2) { sanei_usb_attach_matching_devices (line, attach_one); } else { /* Garbage. Ignore. */ DBG (DBG_warning, "bad configuration line: \"%s\" - ignoring.\n", line); } } fclose (fp); DBG (DBG_proc, "sane_init: leave\n"); return SANE_STATUS_GOOD; } SANE_Status sane_get_devices (const SANE_Device *** device_list, SANE_Bool local_only) { Lexmark2_Scanner *dev; int i; DBG (DBG_proc, "sane_get_devices: enter\n"); local_only = local_only; /* silence gcc */ if (devlist) free (devlist); devlist = malloc ((num_devices + 1) * sizeof (devlist[0])); if (!devlist) return SANE_STATUS_NO_MEM; i = 0; for (dev = first_dev; i < num_devices; dev = dev->next) devlist[i++] = &dev->sane; devlist[i++] = 0; *device_list = devlist; DBG (DBG_proc, "sane_get_devices: exit\n"); return SANE_STATUS_GOOD; } SANE_Status sane_open (SANE_String_Const devicename, SANE_Handle * handle) { Lexmark2_Scanner *dev; SANE_Status status; DBG (DBG_proc, "sane_open: enter\n"); /* search for devicename */ if (devicename[0]) { DBG (DBG_info, "sane_open: devicename=%s\n", devicename); for (dev = first_dev; dev; dev = dev->next) { if (strcmp (dev->sane.name, devicename) == 0) { DBG (DBG_error, "sane_name %s, devicename %s\n", dev->sane.name, devicename); break; } } DBG (DBG_error, "sane_name %s, devicename %s\n", dev->sane.name, devicename); if (!dev) { status = attach_scanner (devicename, &dev); if (status != SANE_STATUS_GOOD) { return status; } } } else { DBG (DBG_sane_info, "sane_open: no devicename, opening first device\n"); dev = first_dev; /* empty devicename -> use first device */ } if (!dev) { DBG (DBG_error, "No scanner found\n"); return SANE_STATUS_INVAL; } lexmark2_init_options (dev); *handle = dev; /* release the interface to allow device sharing */ /* sanei_usb_release_interface (dev->fd, 0); */ DBG (DBG_proc, "sane_open: exit\n"); return SANE_STATUS_GOOD; } const SANE_Option_Descriptor * sane_get_option_descriptor (SANE_Handle handle, SANE_Int option) { Lexmark2_Scanner *dev = handle; DBG (DBG_proc, "sane_get_option_descriptor: enter, option %d\n", option); if ((unsigned) option >= OPT_NUM_OPTIONS) { return NULL; } DBG (DBG_proc, "sane_get_option_descriptor: exit\n"); return dev->opt + option; } SANE_Status sane_control_option (SANE_Handle handle, SANE_Int option, SANE_Action action, void *val, SANE_Int * info) { Lexmark2_Scanner *dev = handle; SANE_Status status; SANE_Word cap; DBG (DBG_proc, "sane_control_option: enter, option %d, action %d\n", option, action); if (info) { *info = 0; } if (dev->scanning) { return SANE_STATUS_DEVICE_BUSY; } if (option < 0 || option >= OPT_NUM_OPTIONS) { return SANE_STATUS_INVAL; } cap = dev->opt[option].cap; if (!SANE_OPTION_IS_ACTIVE (cap)) { return SANE_STATUS_INVAL; } if (action == SANE_ACTION_GET_VALUE) { switch (option) { /* word options */ case OPT_NUM_OPTS: case OPT_RESOLUTION: case OPT_TL_Y: case OPT_BR_Y: case OPT_TL_X: case OPT_BR_X: case OPT_PREVIEW: case OPT_BRIGHTNESS: case OPT_CONTRAST: case OPT_THRESHOLD: case OPT_BLACK_LEVEL: case OPT_WHITE_LEVEL_R: case OPT_WHITE_LEVEL_G: case OPT_WHITE_LEVEL_B: *(SANE_Word *) val = dev->val[option].w; return SANE_STATUS_GOOD; /* string options */ case OPT_MODE: case OPT_DITHER: case OPT_FILTER_COLOR: strcpy (val, dev->val[option].s); return SANE_STATUS_GOOD; default: return SANE_STATUS_INVAL; } } else if (action == SANE_ACTION_SET_VALUE) { if (!SANE_OPTION_IS_SETTABLE (cap)) { DBG (DBG_error, "could not set option, not settable\n"); return SANE_STATUS_INVAL; } status = sanei_constrain_value (dev->opt + option, val, info); if (status != SANE_STATUS_GOOD) { DBG (DBG_error, "could not set option, invalid value\n"); return status; } switch (option) { /* Numeric side-effect options */ case OPT_TL_Y: case OPT_BR_Y: case OPT_TL_X: case OPT_BR_X: case OPT_THRESHOLD: case OPT_RESOLUTION: case OPT_BRIGHTNESS: case OPT_CONTRAST: case OPT_BLACK_LEVEL: case OPT_WHITE_LEVEL_R: case OPT_WHITE_LEVEL_G: case OPT_WHITE_LEVEL_B: if (info) { *info |= SANE_INFO_RELOAD_PARAMS; } dev->val[option].w = *(SANE_Word *) val; return SANE_STATUS_GOOD; /* Numeric side-effect free options */ case OPT_PREVIEW: dev->val[option].w = *(SANE_Word *) val; return SANE_STATUS_GOOD; /* String side-effect free options */ case OPT_DITHER: free (dev->val[option].s); dev->val[option].s = (SANE_String) strdup (val); return SANE_STATUS_GOOD; case OPT_FILTER_COLOR: free (dev->val[option].s); dev->val[option].s = (SANE_String) strdup (val); return SANE_STATUS_GOOD; /* String side-effect options */ case OPT_MODE: if (strcmp (dev->val[option].s, val) == 0) return SANE_STATUS_GOOD; free (dev->val[OPT_MODE].s); dev->val[OPT_MODE].s = (SANE_Char *) strdup (val); dev->opt[OPT_DITHER].cap |= SANE_CAP_INACTIVE; dev->opt[OPT_FILTER_COLOR].cap |= SANE_CAP_INACTIVE; dev->opt[OPT_THRESHOLD].cap &= ~SANE_CAP_INACTIVE; dev->opt[OPT_BLACK_LEVEL].cap &= ~SANE_CAP_INACTIVE; if (strcmp (dev->val[OPT_MODE].s, SANE_VALUE_SCAN_MODE_LINEART) == 0) { dev->scan_mode = LEXMARK2_LINEART; dev->depth = 8; dev->opt[OPT_DITHER].cap &= ~SANE_CAP_INACTIVE; dev->opt[OPT_FILTER_COLOR].cap &= ~SANE_CAP_INACTIVE; dev->opt[OPT_THRESHOLD].cap &= ~SANE_CAP_INACTIVE; } else if (strcmp (dev->val[OPT_MODE].s, SANE_VALUE_SCAN_MODE_GRAY) == 0) { dev->scan_mode = LEXMARK2_GRAY; dev->depth = 8; dev->opt[OPT_WHITE_LEVEL_R].cap &= ~SANE_CAP_INACTIVE; dev->opt[OPT_WHITE_LEVEL_G].cap &= ~SANE_CAP_INACTIVE; dev->opt[OPT_WHITE_LEVEL_B].cap &= ~SANE_CAP_INACTIVE; dev->opt[OPT_FILTER_COLOR].cap &= ~SANE_CAP_INACTIVE; } else if (strcmp (dev->val[OPT_MODE].s, SANE_VALUE_SCAN_MODE_COLOR) == 0) { dev->scan_mode = LEXMARK2_COLOR; dev->depth = 8; dev->opt[OPT_WHITE_LEVEL_R].cap &= ~SANE_CAP_INACTIVE; dev->opt[OPT_WHITE_LEVEL_G].cap &= ~SANE_CAP_INACTIVE; dev->opt[OPT_WHITE_LEVEL_B].cap &= ~SANE_CAP_INACTIVE; } /* The Lexmark2 supports only a handful of resolution. */ if (dev->resolutions_list != NULL) { int i; dev->opt[OPT_RESOLUTION].constraint_type = SANE_CONSTRAINT_WORD_LIST; dev->opt[OPT_RESOLUTION].constraint.word_list = dev->resolutions_list; /* If the resolution isn't in the list, set a default. */ for (i = 1; i <= dev->resolutions_list[0]; i++) { if (dev->resolutions_list[i] >= dev->val[OPT_RESOLUTION].w) break; } if (i > dev->resolutions_list[0]) { /* Too big. Take default. */ dev->val[OPT_RESOLUTION].w = DEF_RESOLUTION; } else { /* Take immediate superioir value. */ dev->val[OPT_RESOLUTION].w = dev->resolutions_list[i]; } } /* String side-effect options */ if (info) { *info |= SANE_INFO_RELOAD_OPTIONS | SANE_INFO_RELOAD_PARAMS; } return SANE_STATUS_GOOD; default: return SANE_STATUS_INVAL; } } DBG (DBG_proc, "sane_control_option: exit, bad\n"); return SANE_STATUS_UNSUPPORTED; } SANE_Status sane_get_parameters (SANE_Handle handle, SANE_Parameters * params) { Lexmark2_Scanner *dev = handle; DBG (DBG_proc, "sane_get_parameters: enter\n"); if (!(dev->scanning)) { /* Setup the parameters for the scan. These values will be re-used * in the SET WINDOWS command. */ if (dev->val[OPT_PREVIEW].w == SANE_TRUE) { dev->x_resolution = 150; /* will later be changed to 100 */ dev->y_resolution = 150; /* will later be changed to 100 */ dev->x_tl = 0; dev->y_tl = 0; dev->x_br = mmToIlu (SANE_UNFIX (dev->hw->x_range.max)); dev->y_br = mmToIlu (SANE_UNFIX (dev->hw->y_range.max)); } else { dev->x_resolution = dev->val[OPT_RESOLUTION].w; dev->y_resolution = dev->val[OPT_RESOLUTION].w; dev->x_tl = mmToIlu (SANE_UNFIX (dev->val[OPT_TL_X].w)); dev->y_tl = mmToIlu (SANE_UNFIX (dev->val[OPT_TL_Y].w)); dev->x_br = mmToIlu (SANE_UNFIX (dev->val[OPT_BR_X].w)); dev->y_br = mmToIlu (SANE_UNFIX (dev->val[OPT_BR_Y].w)); } if (dev->x_resolution > dev->hw->x_resolution_max) { dev->x_resolution = dev->hw->x_resolution_max; } /* Check the corners are OK. */ if (dev->x_tl > dev->x_br) { int s; s = dev->x_tl; dev->x_tl = dev->x_br; dev->x_br = s; } if (dev->y_tl > dev->y_br) { int s; s = dev->y_tl; dev->y_tl = dev->y_br; dev->y_br = s; } dev->width = dev->x_br - dev->x_tl; dev->length = dev->y_br - dev->y_tl; /* Prepare the parameters for the caller. */ memset (&dev->params, 0, sizeof (SANE_Parameters)); dev->params.last_frame = SANE_TRUE; switch (dev->scan_mode) { case LEXMARK2_LINEART: dev->params.format = SANE_FRAME_GRAY; dev->params.pixels_per_line = ((dev->width * dev->x_resolution) / dev->hw->x_resolution_max) & ~0x7; dev->params.bytes_per_line = dev->params.pixels_per_line / 8; dev->params.depth = 1; dev->color_adjust = NULL; break; case LEXMARK2_GRAY: dev->params.format = SANE_FRAME_GRAY; dev->params.pixels_per_line = ((dev->width * dev->x_resolution) / dev->hw->x_resolution_max); dev->params.bytes_per_line = dev->params.pixels_per_line; dev->params.depth = 8; dev->color_adjust = NULL; break; case LEXMARK2_COLOR: dev->params.format = SANE_FRAME_RGB; dev->params.pixels_per_line = ((dev->width * dev->x_resolution) / dev->hw->x_resolution_max); dev->params.bytes_per_line = dev->params.pixels_per_line * 3; dev->params.depth = 8; if (dev->resolutions_list != NULL) { /* This scanner has a fixed number of supported * resolutions. Find the color shift for that * resolution. */ int i; for (i = 0; dev->hw->color_adjust[i].resolution_y != dev->y_resolution; i++); dev->color_adjust = &dev->hw->color_adjust[i]; } else { dev->color_adjust = &dev->hw->color_adjust[0]; } break; } dev->params.lines = (dev->length * dev->y_resolution) / dev->hw->x_resolution_max; } /* Return the current values. */ if (params) { *params = (dev->params); } DBG (DBG_proc, "sane_get_parameters: exit\n"); return SANE_STATUS_GOOD; } SANE_Status sane_start (SANE_Handle handle) { Lexmark2_Scanner *dev = handle; SANE_Status status; DBG (DBG_proc, "sane_start: enter\n"); if (!(dev->scanning)) { sane_get_parameters (dev, NULL); /* Open again the scanner */ /* if (sanei_usb_open (dev->devicename, &(dev->fd)) != 0) { DBG (DBG_error, "ERROR: sane_start: open failed\n"); return SANE_STATUS_INVAL; } */ /* Initialize the scanner. */ status = lexmark2_scanner_init (dev); if (status) { DBG (DBG_error, "ERROR: failed to init the scanner\n"); lexmark2_close (dev); return status; } /* The scanner must be ready. */ status = lexmark2_wait_scanner (dev); if (status) { lexmark2_close (dev); return status; } status = lexmark2_set_window (dev); if (status) { lexmark2_close (dev); return status; } status = lexmark2_get_scan_size (dev); if (status) { lexmark2_close (dev); return status; } /* Compute the length necessary in image. The first part will store * the complete lines, and the rest is used to stored ahead * rasters. */ if (dev->color_adjust) { dev->raster_ahead = (2 * dev->color_adjust->color_shift) * dev->params.bytes_per_line; } else { dev->raster_ahead = 0; } dev->image_size = dev->buffer_size + dev->raster_ahead; dev->image = malloc (dev->image_size); if (dev->image == NULL) { return SANE_STATUS_NO_MEM; } /* Rasters are meaningfull only in color mode. */ dev->raster_size = dev->params.pixels_per_line; dev->raster_real = dev->params.lines * 3; dev->raster_num = 0; dev->line = 0; status = lexmark2_scan (dev); if (status) { lexmark2_close (dev); return status; } } dev->image_end = 0; dev->image_begin = 0; dev->bytes_left = dev->params.bytes_per_line * dev->params.lines; dev->real_bytes_left = dev->params.bytes_per_line * dev->params.lines; dev->scanning = SANE_TRUE; DBG (DBG_proc, "sane_start: exit\n"); return SANE_STATUS_GOOD; } SANE_Status sane_read (SANE_Handle handle, SANE_Byte * buf, SANE_Int max_len, SANE_Int * len) { SANE_Status status; Lexmark2_Scanner *dev = handle; size_t size; int buf_offset; /* offset into buf */ DBG (DBG_proc, "sane_read: enter\n"); *len = 0; if (!(dev->scanning)) { DBG (DBG_proc, "sane_read: before do_cancel enter\n"); /* OOPS, not scanning, stop a scan. */ lexmark2_reset_scanner (dev); lexmark2_close (dev); dev->scanning = SANE_FALSE; return SANE_STATUS_CANCELLED; } if (dev->bytes_left <= 0) { return (SANE_STATUS_EOF); } buf_offset = 0; do { if (dev->image_begin == dev->image_end) { /* Fill image */ status = lexmark2_fill_image (dev); if (status != SANE_STATUS_GOOD) { return (status); } } /* Something must have been read */ if (dev->image_begin == dev->image_end) { DBG (DBG_info, "sane_read: nothing read\n"); return SANE_STATUS_IO_ERROR; } /* Copy the data to the frontend buffer. */ size = max_len - buf_offset; if (size > dev->bytes_left) { size = dev->bytes_left; } lexmark2_copy_raw_to_frontend (dev, buf + buf_offset, &size); buf_offset += size; dev->bytes_left -= size; *len += size; if (dev->bytes_left < size) dev->bytes_left = 0; } while ((buf_offset != max_len) && dev->bytes_left); DBG (DBG_info, "sane_read: leave, bytes_left=%d\n", dev->bytes_left); return SANE_STATUS_GOOD; } SANE_Status sane_set_io_mode (SANE_Handle handle, SANE_Bool non_blocking) { DBG (DBG_proc, "sane_set_io_mode: enter\n"); handle = handle; /* silence gcc */ non_blocking = non_blocking; /* silence gcc */ DBG (DBG_proc, "sane_set_io_mode: exit\n"); return SANE_STATUS_UNSUPPORTED; } SANE_Status sane_get_select_fd (SANE_Handle handle, SANE_Int * fd) { DBG (DBG_proc, "sane_get_select_fd: enter\n"); handle = handle; /* silence gcc */ fd = fd; /* silence gcc */ DBG (DBG_proc, "sane_get_select_fd: exit\n"); return SANE_STATUS_UNSUPPORTED; } void sane_cancel (SANE_Handle handle) { Lexmark2_Scanner *dev = handle; DBG (DBG_proc, "sane_cancel: enter\n"); /* Stop a scan. */ if (dev->scanning == SANE_TRUE) { /* Reset the scanner */ lexmark2_reset_scanner (dev); lexmark2_close (dev); } dev->scanning = SANE_FALSE; DBG (DBG_proc, "sane_cancel: exit\n"); } void sane_close (SANE_Handle handle) { Lexmark2_Scanner *dev = handle; Lexmark2_Scanner *dev_tmp; DBG (DBG_proc, "sane_close: enter\n"); /* Stop a scan. */ if (dev->scanning == SANE_TRUE) { /* Reset the scanner */ lexmark2_reset_scanner (dev); lexmark2_close (dev); } dev->scanning = SANE_FALSE; /* Unlink dev. */ if (first_dev == dev) { first_dev = dev->next; } else { dev_tmp = first_dev; while (dev_tmp->next && dev_tmp->next != dev) { dev_tmp = dev_tmp->next; } if (dev_tmp->next != NULL) { dev_tmp->next = dev_tmp->next->next; } } lexmark2_free (dev); num_devices--; DBG (DBG_proc, "sane_close: exit\n"); } void sane_exit (void) { DBG (DBG_proc, "sane_exit: enter\n"); while (first_dev) { sane_close (first_dev); } if (devlist) { free (devlist); devlist = NULL; } DBG (DBG_proc, "sane_exit: exit\n"); }