diff options
Diffstat (limited to 'backend/lexmark.c')
| -rw-r--r-- | backend/lexmark.c | 1348 |
1 files changed, 1348 insertions, 0 deletions
diff --git a/backend/lexmark.c b/backend/lexmark.c new file mode 100644 index 0000000..e0cd21f --- /dev/null +++ b/backend/lexmark.c @@ -0,0 +1,1348 @@ +/* lexmark.c: SANE backend for Lexmark scanners. + + (C) 2003-2004 Lexmark International, Inc. (Original Source code) + (C) 2005 Fred Odendaal + (C) 2006-2013 Stéphane Voltz <stef.dev@free.fr> + (C) 2010 "Torsten Houwaart" <ToHo@gmx.de> X74 support + + 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. + + **************************************************************************/ + +#include "lexmark.h" + +#define LEXMARK_CONFIG_FILE "lexmark.conf" +#define BUILD 32 +#define MAX_OPTION_STRING_SIZE 255 + +static Lexmark_Device *first_lexmark_device = 0; +static SANE_Int num_lexmark_device = 0; +static const SANE_Device **sane_device_list = NULL; + +/* Program globals F.O - Should this be per device?*/ +static SANE_Bool initialized = SANE_FALSE; + +static SANE_String_Const mode_list[] = { + SANE_VALUE_SCAN_MODE_COLOR, + SANE_VALUE_SCAN_MODE_GRAY, + SANE_VALUE_SCAN_MODE_LINEART, + NULL +}; + +/* possible resolutions are: 75x75, 150x150, 300x300, 600x600, 600x1200 */ + +static SANE_Int x1100_dpi_list[] = { + 5, 75, 150, 300, 600, 1200 +}; + +static SANE_Int a920_dpi_list[] = { + 4, 75, 150, 300, 600 +}; + +static SANE_Int x1200_dpi_list[] = { + 4, 75, 150, 300, 600 +}; + +static SANE_Int x74_dpi_list[] = { + 75, 150, 300, 600 +}; + +static SANE_Range threshold_range = { + SANE_FIX (0.0), /* minimum */ + SANE_FIX (100.0), /* maximum */ + SANE_FIX (1.0) /* quantization */ +}; + +static const SANE_Range gain_range = { + 0, /* minimum */ + 31, /* maximum */ + 0 /* quantization */ +}; + +/* for now known models (2 ...) have the same scan window geometry. + coordinates are expressed in pixels, with a quantization factor of + 8 to have 'even' coordinates at 75 dpi */ +static SANE_Range x_range = { + 0, /* minimum */ + 5104, /* maximum */ + 16 /* quantization : 16 is required so we + never have an odd width */ +}; + +static SANE_Range y_range = { + 0, /* minimum */ + 6848, /* maximum */ + /* 7032, for X74 */ + 8 /* quantization */ +}; + +/* static functions */ +static SANE_Status init_options (Lexmark_Device * lexmark_device); +static SANE_Status attachLexmark (SANE_String_Const devname); + +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, or Line Art */ + 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_Word); + od->cap = SANE_CAP_SOFT_DETECT | SANE_CAP_SOFT_SELECT; + od->constraint_type = SANE_CONSTRAINT_WORD_LIST; + switch (dev->model.sensor_type) + { + case X1100_2C_SENSOR: + case A920_SENSOR: + od->constraint.word_list = a920_dpi_list; + break; + case X1100_B2_SENSOR: + od->constraint.word_list = x1100_dpi_list; + break; + case X1200_SENSOR: + case X1200_USB2_SENSOR: + od->constraint.word_list = x1200_dpi_list; + break; + case X74_SENSOR: + od->constraint.word_list = x74_dpi_list; + break; + } + dev->val[OPT_RESOLUTION].w = 75; + + /* 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_SOFT_DETECT | SANE_CAP_SOFT_SELECT; + 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_SOFT_DETECT | SANE_CAP_SOFT_SELECT; + 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_SOFT_DETECT | SANE_CAP_SOFT_SELECT; + 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 = x_range.max; + + /* 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 = y_range.max; + + /* threshold */ + od = &(dev->opt[OPT_THRESHOLD]); + od->name = SANE_NAME_THRESHOLD; + od->title = SANE_TITLE_THRESHOLD; + od->desc = SANE_DESC_THRESHOLD; + od->type = SANE_TYPE_FIXED; + od->unit = SANE_UNIT_PERCENT; + od->size = sizeof (SANE_Fixed); + od->cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT | SANE_CAP_INACTIVE; + od->constraint_type = SANE_CONSTRAINT_RANGE; + od->constraint.range = &threshold_range; + dev->val[OPT_THRESHOLD].w = SANE_FIX (50.0); + + /* gain group */ + dev->opt[OPT_MANUAL_GAIN].name = "manual-channel-gain"; + dev->opt[OPT_MANUAL_GAIN].title = SANE_I18N ("Gain"); + dev->opt[OPT_MANUAL_GAIN].desc = SANE_I18N ("Color channels gain settings"); + dev->opt[OPT_MANUAL_GAIN].type = SANE_TYPE_BOOL; + dev->opt[OPT_MANUAL_GAIN].cap = + SANE_CAP_SOFT_DETECT | SANE_CAP_SOFT_SELECT | SANE_CAP_ADVANCED; + dev->opt[OPT_MANUAL_GAIN].size = sizeof (SANE_Bool); + dev->val[OPT_MANUAL_GAIN].w = SANE_FALSE; + + /* gray gain */ + dev->opt[OPT_GRAY_GAIN].name = "gray-gain"; + dev->opt[OPT_GRAY_GAIN].title = SANE_I18N ("Gray gain"); + dev->opt[OPT_GRAY_GAIN].desc = SANE_I18N ("Sets gray channel gain"); + dev->opt[OPT_GRAY_GAIN].type = SANE_TYPE_INT; + dev->opt[OPT_GRAY_GAIN].cap = + SANE_CAP_SOFT_DETECT | SANE_CAP_SOFT_SELECT | SANE_CAP_INACTIVE | + SANE_CAP_ADVANCED; + dev->opt[OPT_GRAY_GAIN].unit = SANE_UNIT_NONE; + dev->opt[OPT_GRAY_GAIN].size = sizeof (SANE_Int); + dev->opt[OPT_GRAY_GAIN].constraint_type = SANE_CONSTRAINT_RANGE; + dev->opt[OPT_GRAY_GAIN].constraint.range = &gain_range; + dev->val[OPT_GRAY_GAIN].w = 10; + + /* red gain */ + dev->opt[OPT_RED_GAIN].name = "red-gain"; + dev->opt[OPT_RED_GAIN].title = SANE_I18N ("Red gain"); + dev->opt[OPT_RED_GAIN].desc = SANE_I18N ("Sets red channel gain"); + dev->opt[OPT_RED_GAIN].type = SANE_TYPE_INT; + dev->opt[OPT_RED_GAIN].cap = + SANE_CAP_SOFT_DETECT | SANE_CAP_SOFT_SELECT | SANE_CAP_INACTIVE | + SANE_CAP_ADVANCED; + dev->opt[OPT_RED_GAIN].unit = SANE_UNIT_NONE; + dev->opt[OPT_RED_GAIN].size = sizeof (SANE_Int); + dev->opt[OPT_RED_GAIN].constraint_type = SANE_CONSTRAINT_RANGE; + dev->opt[OPT_RED_GAIN].constraint.range = &gain_range; + dev->val[OPT_RED_GAIN].w = 10; + + /* green gain */ + dev->opt[OPT_GREEN_GAIN].name = "green-gain"; + dev->opt[OPT_GREEN_GAIN].title = SANE_I18N ("Green gain"); + dev->opt[OPT_GREEN_GAIN].desc = SANE_I18N ("Sets green channel gain"); + dev->opt[OPT_GREEN_GAIN].type = SANE_TYPE_INT; + dev->opt[OPT_GREEN_GAIN].cap = + SANE_CAP_SOFT_DETECT | SANE_CAP_SOFT_SELECT | SANE_CAP_INACTIVE | + SANE_CAP_ADVANCED; + dev->opt[OPT_GREEN_GAIN].unit = SANE_UNIT_NONE; + dev->opt[OPT_GREEN_GAIN].size = sizeof (SANE_Int); + dev->opt[OPT_GREEN_GAIN].constraint_type = SANE_CONSTRAINT_RANGE; + dev->opt[OPT_GREEN_GAIN].constraint.range = &gain_range; + dev->val[OPT_GREEN_GAIN].w = 10; + + /* blue gain */ + dev->opt[OPT_BLUE_GAIN].name = "blue-gain"; + dev->opt[OPT_BLUE_GAIN].title = SANE_I18N ("Blue gain"); + dev->opt[OPT_BLUE_GAIN].desc = SANE_I18N ("Sets blue channel gain"); + dev->opt[OPT_BLUE_GAIN].type = SANE_TYPE_INT; + dev->opt[OPT_BLUE_GAIN].cap = + SANE_CAP_SOFT_DETECT | SANE_CAP_SOFT_SELECT | SANE_CAP_INACTIVE | + SANE_CAP_ADVANCED; + dev->opt[OPT_BLUE_GAIN].unit = SANE_UNIT_NONE; + dev->opt[OPT_BLUE_GAIN].size = sizeof (SANE_Int); + dev->opt[OPT_BLUE_GAIN].constraint_type = SANE_CONSTRAINT_RANGE; + dev->opt[OPT_BLUE_GAIN].constraint.range = &gain_range; + dev->val[OPT_BLUE_GAIN].w = 10; + + return SANE_STATUS_GOOD; +} + + +/***************************** SANE API ****************************/ + +SANE_Status +attachLexmark (SANE_String_Const devname) +{ + Lexmark_Device *lexmark_device; + SANE_Int dn, vendor, product, variant; + SANE_Status status; + + DBG (2, "attachLexmark: devname=%s\n", devname); + + for (lexmark_device = first_lexmark_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; + +#ifdef FAKE_USB + status = SANE_STATUS_GOOD; +#else + status = sanei_usb_open (devname, &dn); +#endif + if (status != SANE_STATUS_GOOD) + { + DBG (1, "attachLexmark: couldn't open device `%s': %s\n", devname, + sane_strstatus (status)); + return status; + } + else + DBG (2, "attachLexmark: device `%s' successfully opened\n", devname); + +#ifdef FAKE_USB + status = SANE_STATUS_GOOD; + /* put the id of the model you want to fake here */ + vendor = 0x043d; + product = 0x007c; /* X11xx */ + variant = 0xb2; +#else + variant = 0; + status = sanei_usb_get_vendor_product (dn, &vendor, &product); +#endif + if (status != SANE_STATUS_GOOD) + { + DBG (1, + "attachLexmark: couldn't get vendor and product ids of device `%s': %s\n", + devname, sane_strstatus (status)); +#ifndef FAKE_USB + sanei_usb_close (dn); +#endif + return status; + } +#ifndef FAKE_USB + sanei_usb_close (dn); +#endif + + DBG (2, "attachLexmark: testing device `%s': 0x%04x:0x%04x, variant=%d\n", + devname, vendor, product, variant); + if (sanei_lexmark_low_assign_model (lexmark_device, + devname, + vendor, + product, variant) != SANE_STATUS_GOOD) + { + DBG (2, "attachLexmark: unsupported device `%s': 0x%04x:0x%04x\n", + devname, vendor, product); + return SANE_STATUS_UNSUPPORTED; + } + + /* add new device to device list */ + + /* there are two variant of the scanner with the same USB id, + * so we need to read registers from scanner to detect which one + * is really connected */ + status = sanei_lexmark_low_open_device (lexmark_device); + sanei_usb_close (lexmark_device->devnum); + + /* set up scanner start status */ + sanei_lexmark_low_init (lexmark_device); + + /* Set the default resolution here */ + lexmark_device->x_dpi = 75; + lexmark_device->y_dpi = 75; + + /* Make the pointer to the read buffer null here */ + lexmark_device->read_buffer = NULL; + + /* Set the default threshold for lineart mode here */ + lexmark_device->threshold = 0x80; + + lexmark_device->shading_coeff = NULL; + + /* mark device as present */ + lexmark_device->missing = SANE_FALSE; + + /* insert it a the start of the chained list */ + lexmark_device->next = first_lexmark_device; + first_lexmark_device = lexmark_device; + + num_lexmark_device++; + + return status; +} + +/** probe for supported lexmark devices + * This function scan usb and try to attached to scanner + * configured in lexmark.conf . + */ +static SANE_Status +probe_lexmark_devices (void) +{ + FILE *fp; + SANE_Char line[PATH_MAX]; + const char *lp; + SANE_Int vendor, product; + size_t len; + Lexmark_Device *dev; + + /* mark already detected devices as missing, during device probe + * detected devices will clear this flag */ + dev = first_lexmark_device; + while (dev != NULL) + { + dev->missing = SANE_TRUE; + dev = dev->next; + } + + /* open config file, parse option and try to open + * any device configure in it */ + fp = sanei_config_open (LEXMARK_CONFIG_FILE); + if (!fp) + { + return SANE_STATUS_ACCESS_DENIED; + } + + while (sanei_config_read (line, PATH_MAX, fp)) + { + /* ignore comments */ + if (line[0] == '#') + continue; + len = strlen (line); + + /* delete newline characters at end */ + if (line[len - 1] == '\n') + line[--len] = '\0'; + + lp = sanei_config_skip_whitespace (line); + /* skip empty lines */ + if (*lp == 0) + continue; + + if (sscanf (lp, "usb %i %i", &vendor, &product) == 2) + ; + else if (strncmp ("libusb", lp, 6) == 0) + ; + else if ((strncmp ("usb", lp, 3) == 0) && isspace (lp[3])) + { + lp += 3; + lp = sanei_config_skip_whitespace (lp); + } + else + continue; + +#ifdef FAKE_USB + attachLexmark ("FAKE_USB"); +#else + sanei_usb_attach_matching_devices (lp, attachLexmark); +#endif + } + + fclose (fp); + return SANE_STATUS_GOOD; +} + +SANE_Status +sane_init (SANE_Int * version_code, + SANE_Auth_Callback __sane_unused__ authorize) +{ + SANE_Status status; + + DBG_INIT (); + + DBG (1, "SANE Lexmark backend version %d.%d.%d-devel\n", SANE_CURRENT_MAJOR, + V_MINOR, BUILD); + + DBG (2, "sane_init: version_code=%p\n", (void *) version_code); + + if (version_code) + *version_code = SANE_VERSION_CODE (SANE_CURRENT_MAJOR, V_MINOR, BUILD); + +#ifndef FAKE_USB + sanei_usb_init (); +#endif + + status = probe_lexmark_devices (); + + if (status == SANE_STATUS_GOOD) + { + initialized = SANE_TRUE; + } + else + { + initialized = SANE_FALSE; + } + + return status; +} + +void +sane_exit (void) +{ + Lexmark_Device *lexmark_device, *next_lexmark_device; + + DBG (2, "sane_exit\n"); + + if (!initialized) + return; + + for (lexmark_device = first_lexmark_device; lexmark_device; + lexmark_device = next_lexmark_device) + { + next_lexmark_device = lexmark_device->next; + sanei_lexmark_low_destroy (lexmark_device); + free (lexmark_device); + } + + if (sane_device_list) + free (sane_device_list); + + sanei_usb_exit(); + initialized = SANE_FALSE; + + return; +} + +SANE_Status +sane_get_devices (const SANE_Device *** device_list, SANE_Bool local_only) +{ + Lexmark_Device *lexmark_device; + SANE_Int index; + + DBG (2, "sane_get_devices: device_list=%p, local_only=%d\n", + (void *) device_list, local_only); + + /* hot-plug case : detection of newly connected scanners */ + sanei_usb_scan_devices (); + probe_lexmark_devices (); + + if (sane_device_list) + free (sane_device_list); + + sane_device_list = malloc ((num_lexmark_device + 1) * + sizeof (sane_device_list[0])); + + if (!sane_device_list) + return SANE_STATUS_NO_MEM; + + index = 0; + lexmark_device = first_lexmark_device; + while (lexmark_device != NULL) + { + if (lexmark_device->missing == SANE_FALSE) + { + sane_device_list[index] = &(lexmark_device->sane); + index++; + } + lexmark_device = lexmark_device->next; + } + sane_device_list[index] = 0; + + *device_list = sane_device_list; + + return SANE_STATUS_GOOD; +} + + +/** + * Open the backend, ie return the struct handle of a detected scanner + * The struct returned is choosne if it matches the name given, which is + * usefull when several scanners handled by the backend have been detected. + * However, special case empty string "" and "lexmark" pick the first + * available handle. + */ +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); + + if (!initialized) + { + DBG (2, "sane_open: not initialized\n"); + return SANE_STATUS_INVAL; + } + + if (!handle) + { + DBG (2, "sane_open: no handle\n"); + return SANE_STATUS_INVAL; + } + + /* walk the linked list of scanner device until ther is a match + * with the device name */ + for (lexmark_device = first_lexmark_device; lexmark_device; + lexmark_device = lexmark_device->next) + { + DBG (2, "sane_open: 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; + + if (!lexmark_device) + { + DBG (2, "sane_open: Not a lexmark device\n"); + return SANE_STATUS_INVAL; + } + + status = init_options (lexmark_device); + if (status != SANE_STATUS_GOOD) + return status; + + status = sanei_lexmark_low_open_device (lexmark_device); + DBG (2, "sane_open: end.\n"); + + return status; +} + +void +sane_close (SANE_Handle handle) +{ + Lexmark_Device *lexmark_device; + + DBG (2, "sane_close: handle=%p\n", (void *) handle); + + if (!initialized) + return; + + for (lexmark_device = first_lexmark_device; lexmark_device; + lexmark_device = lexmark_device->next) + { + if (lexmark_device == handle) + break; + } + + if (!lexmark_device) + return; + + sanei_lexmark_low_close_device (lexmark_device); + + return; +} + +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); + + if (!initialized) + return NULL; + + /* Check for valid option number */ + if ((option < 0) || (option >= NUM_OPTIONS)) + return NULL; + + for (lexmark_device = first_lexmark_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, "sane_get_option_descriptor: name=%s\n", + lexmark_device->opt[option].name); + } + + return &(lexmark_device->opt[option]); +} + +/* rebuilds parameters if needed, called each time SANE_INFO_RELOAD_OPTIONS + is set */ +static void +calc_parameters (Lexmark_Device * lexmark_device) +{ + if (strcmp (lexmark_device->val[OPT_MODE].s, + SANE_VALUE_SCAN_MODE_LINEART) == 0) + { + lexmark_device->opt[OPT_THRESHOLD].cap &= ~SANE_CAP_INACTIVE; + } + else + { + lexmark_device->opt[OPT_THRESHOLD].cap |= SANE_CAP_INACTIVE; + } + + /* changing color mode implies changing gain setting */ + if (lexmark_device->val[OPT_MANUAL_GAIN].w == SANE_TRUE) + { + if (strcmp (lexmark_device->val[OPT_MODE].s, SANE_VALUE_SCAN_MODE_COLOR) + != 0) + { + lexmark_device->opt[OPT_GRAY_GAIN].cap &= ~SANE_CAP_INACTIVE; + lexmark_device->opt[OPT_RED_GAIN].cap |= SANE_CAP_INACTIVE; + lexmark_device->opt[OPT_GREEN_GAIN].cap |= SANE_CAP_INACTIVE; + lexmark_device->opt[OPT_BLUE_GAIN].cap |= SANE_CAP_INACTIVE; + } + else + { + lexmark_device->opt[OPT_GRAY_GAIN].cap |= SANE_CAP_INACTIVE; + lexmark_device->opt[OPT_RED_GAIN].cap &= ~SANE_CAP_INACTIVE; + lexmark_device->opt[OPT_GREEN_GAIN].cap &= ~SANE_CAP_INACTIVE; + lexmark_device->opt[OPT_BLUE_GAIN].cap &= ~SANE_CAP_INACTIVE; + } + } + else + { + lexmark_device->opt[OPT_GRAY_GAIN].cap |= SANE_CAP_INACTIVE; + lexmark_device->opt[OPT_RED_GAIN].cap |= SANE_CAP_INACTIVE; + lexmark_device->opt[OPT_GREEN_GAIN].cap |= SANE_CAP_INACTIVE; + lexmark_device->opt[OPT_BLUE_GAIN].cap |= SANE_CAP_INACTIVE; + } +} + +SANE_Status +sane_control_option (SANE_Handle handle, SANE_Int option, SANE_Action action, + void *value, SANE_Int * info) +{ + Lexmark_Device *lexmark_device; + SANE_Status status; + SANE_Word w; + + DBG (2, "sane_control_option: handle=%p, opt=%d, act=%d, val=%p, info=%p\n", + (void *) handle, option, action, (void *) value, (void *) info); + + if (!initialized) + return SANE_STATUS_INVAL; + + for (lexmark_device = first_lexmark_device; lexmark_device; + lexmark_device = lexmark_device->next) + { + if (lexmark_device == handle) + break; + } + + if (!lexmark_device) + return SANE_STATUS_INVAL; + + if (value == NULL) + return SANE_STATUS_INVAL; + + if (info != NULL) + *info = 0; + + if (option < 0 || option >= NUM_OPTIONS) + return SANE_STATUS_INVAL; + + if (lexmark_device->opt[option].type == SANE_TYPE_GROUP) + return SANE_STATUS_INVAL; + + switch (action) + { + case SANE_ACTION_SET_AUTO: + + if (!SANE_OPTION_IS_SETTABLE (lexmark_device->opt[option].cap)) + return SANE_STATUS_INVAL; + if (!(lexmark_device->opt[option].cap & SANE_CAP_AUTOMATIC)) + return SANE_STATUS_INVAL; + break; + + 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: + lexmark_device->val[option].w = *(SANE_Int *) value; + sane_get_parameters (handle, 0); + 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_THRESHOLD: + lexmark_device->val[option].w = *(SANE_Fixed *) value; + lexmark_device->threshold = + (0xFF * lexmark_device->val[option].w) / 100; + break; + case OPT_PREVIEW: + lexmark_device->val[option].w = *(SANE_Int *) value; + if (*(SANE_Word *) value) + { + lexmark_device->y_dpi = lexmark_device->val[OPT_RESOLUTION].w; + lexmark_device->val[OPT_RESOLUTION].w = 75; + } + else + { + lexmark_device->val[OPT_RESOLUTION].w = lexmark_device->y_dpi; + } + if (info) + *info |= SANE_INFO_RELOAD_OPTIONS; + sane_get_parameters (handle, 0); + if (info) + *info |= SANE_INFO_RELOAD_PARAMS; + break; + case OPT_GRAY_GAIN: + case OPT_GREEN_GAIN: + case OPT_RED_GAIN: + case OPT_BLUE_GAIN: + lexmark_device->val[option].w = *(SANE_Word *) value; + return SANE_STATUS_GOOD; + break; + case OPT_MODE: + strcpy (lexmark_device->val[option].s, value); + calc_parameters (lexmark_device); + if (info) + *info |= SANE_INFO_RELOAD_PARAMS | SANE_INFO_RELOAD_OPTIONS; + return SANE_STATUS_GOOD; + case OPT_MANUAL_GAIN: + w = *(SANE_Word *) value; + + if (w == lexmark_device->val[OPT_MANUAL_GAIN].w) + return SANE_STATUS_GOOD; /* no change */ + + lexmark_device->val[OPT_MANUAL_GAIN].w = w; + calc_parameters (lexmark_device); + if (info) + *info |= 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_MANUAL_GAIN: + case OPT_GRAY_GAIN: + case OPT_GREEN_GAIN: + case OPT_RED_GAIN: + case OPT_BLUE_GAIN: + 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_THRESHOLD: + *(SANE_Fixed *) value = lexmark_device->val[option].w; + DBG (2, "Option value = %f\n", SANE_UNFIX (*(SANE_Fixed *) value)); + break; + case OPT_MODE: + strcpy (value, lexmark_device->val[option].s); + break; + default: + return SANE_STATUS_INVAL; + } + 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 xres, yres, width_px, height_px; + SANE_Int channels, bitsperchannel; + + DBG (2, "sane_get_parameters: handle=%p, params=%p\n", (void *) handle, + (void *) params); + + if (!initialized) + return SANE_STATUS_INVAL; + + for (lexmark_device = first_lexmark_device; lexmark_device; + lexmark_device = lexmark_device->next) + { + if (lexmark_device == handle) + break; + } + + if (!lexmark_device) + return SANE_STATUS_INVAL; + + yres = lexmark_device->val[OPT_RESOLUTION].w; + if (yres == 1200) + xres = 600; + else + xres = yres; + + /* 24 bit colour = 8 bits/channel for each of the RGB channels */ + channels = 3; + bitsperchannel = 8; + + /* If not color there is only 1 channel */ + if (strcmp (lexmark_device->val[OPT_MODE].s, SANE_VALUE_SCAN_MODE_COLOR) + != 0) + { + channels = 1; + bitsperchannel = 8; + } + + /* geometry in pixels */ + width_px = + lexmark_device->val[OPT_BR_X].w - lexmark_device->val[OPT_TL_X].w; + height_px = + lexmark_device->val[OPT_BR_Y].w - lexmark_device->val[OPT_TL_Y].w; + DBG (7, "sane_get_parameters: tl=(%d,%d) br=(%d,%d)\n", + lexmark_device->val[OPT_TL_X].w, lexmark_device->val[OPT_TL_Y].w, + lexmark_device->val[OPT_BR_X].w, lexmark_device->val[OPT_BR_Y].w); + + + /* we must tell the front end the bitsperchannel for lineart is really */ + /* only 1, so it can calculate the correct image size */ + /* If not color there is only 1 channel */ + if (strcmp (lexmark_device->val[OPT_MODE].s, SANE_VALUE_SCAN_MODE_LINEART) + == 0) + { + bitsperchannel = 1; + } + + device_params = &(lexmark_device->params); + device_params->format = SANE_FRAME_RGB; + if (channels == 1) + device_params->format = SANE_FRAME_GRAY; + device_params->last_frame = SANE_TRUE; + device_params->lines = (height_px * yres) / 600; + device_params->depth = bitsperchannel; + device_params->pixels_per_line = (width_px * xres) / 600; + /* we always read an even number of sensor pixels */ + if (device_params->pixels_per_line & 1) + device_params->pixels_per_line++; + + /* data_size is the size transferred from the scanner to the backend */ + /* therefore bitsperchannel is the same for gray and lineart */ + /* note: bytes_per_line has been divided by 8 in lineart mode */ + lexmark_device->data_size = + channels * device_params->pixels_per_line * device_params->lines; + + if (bitsperchannel == 1) + { + device_params->bytes_per_line = + (SANE_Int) ((7 + device_params->pixels_per_line) / 8); + } + else + { + device_params->bytes_per_line = + (SANE_Int) (channels * device_params->pixels_per_line); + } + DBG (2, "sane_get_parameters: Data size determined as %ld\n", + lexmark_device->data_size); + + DBG (2, "sane_get_parameters: \n"); + if (device_params->format == SANE_FRAME_GRAY) + DBG (2, " format: SANE_FRAME_GRAY\n"); + else if (device_params->format == SANE_FRAME_RGB) + DBG (2, " format: SANE_FRAME_RGB\n"); + else + DBG (2, " format: UNKNOWN\n"); + if (device_params->last_frame == SANE_TRUE) + DBG (2, " last_frame: TRUE\n"); + else + DBG (2, " last_frame: FALSE\n"); + DBG (2, " lines %d\n", device_params->lines); + DBG (2, " depth %d\n", device_params->depth); + DBG (2, " pixels_per_line %d\n", device_params->pixels_per_line); + DBG (2, " bytes_per_line %d\n", device_params->bytes_per_line); + + 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_Int offset; + SANE_Status status; + int resolution; + + DBG (2, "sane_start: handle=%p\n", (void *) handle); + + if (!initialized) + return SANE_STATUS_INVAL; + + for (lexmark_device = first_lexmark_device; lexmark_device; + lexmark_device = lexmark_device->next) + { + if (lexmark_device == handle) + break; + } + + sane_get_parameters (handle, 0); + + if ((lexmark_device->params.lines == 0) || + (lexmark_device->params.pixels_per_line == 0) || + (lexmark_device->params.bytes_per_line == 0)) + { + DBG (2, "sane_start: \n"); + DBG (2, " ERROR: Zero size encountered in:\n"); + DBG (2, + " number of lines, bytes per line, or pixels per line\n"); + return SANE_STATUS_INVAL; + } + + lexmark_device->device_cancelled = SANE_FALSE; + lexmark_device->data_ctr = 0; + lexmark_device->eof = SANE_FALSE; + + + /* Need this cancel_ctr to determine how many times sane_cancel is called + since it is called more than once. */ + lexmark_device->cancel_ctr = 0; + + /* Find Home */ + if (sanei_lexmark_low_search_home_fwd (lexmark_device)) + { + DBG (2, "sane_start: Scan head initially at home position\n"); + } + else + { + /* We may have been rewound too far, so move forward the distance from + the edge to the home position */ + sanei_lexmark_low_move_fwd (0x01a8, lexmark_device, + lexmark_device->shadow_regs); + + /* Scan backwards until we find home */ + sanei_lexmark_low_search_home_bwd (lexmark_device); + } + /* do calibration before offset detection , use sensor max dpi, not motor's one */ + resolution = lexmark_device->val[OPT_RESOLUTION].w; + if (resolution > 600) + { + resolution = 600; + } + + + sanei_lexmark_low_set_scan_regs (lexmark_device, resolution, 0, SANE_FALSE); + status = sanei_lexmark_low_calibration (lexmark_device); + if (status != SANE_STATUS_GOOD) + { + DBG (1, "sane_start: calibration failed : %s ! \n", + sane_strstatus (status)); + return status; + } + + /* At this point we're somewhere in the dot. We need to read a number of + lines greater than the diameter of the dot and determine how many lines + past the dot we've gone. We then use this information to see how far the + scan head must move before starting the scan. */ + /* offset is in 600 dpi unit */ + offset = sanei_lexmark_low_find_start_line (lexmark_device); + DBG (7, "start line offset=%d\n", offset); + + /* Set the shadow registers for scan with the options (resolution, mode, + size) set in the front end. Pass the offset so we can get the vert. + start. */ + sanei_lexmark_low_set_scan_regs (lexmark_device, + lexmark_device->val[OPT_RESOLUTION].w, + offset, SANE_TRUE); + + if (sanei_lexmark_low_start_scan (lexmark_device) == SANE_STATUS_GOOD) + { + DBG (2, "sane_start: scan started\n"); + return SANE_STATUS_GOOD; + } + else + { + lexmark_device->device_cancelled = SANE_TRUE; + return SANE_STATUS_INVAL; + } +} + + +SANE_Status +sane_read (SANE_Handle handle, SANE_Byte * data, + SANE_Int max_length, SANE_Int * length) +{ + Lexmark_Device *lexmark_device; + long bytes_read; + + DBG (2, "sane_read: handle=%p, data=%p, max_length = %d, length=%p\n", + (void *) handle, (void *) data, max_length, (void *) length); + + if (!initialized) + { + DBG (2, "sane_read: Not initialized\n"); + return SANE_STATUS_INVAL; + } + + for (lexmark_device = first_lexmark_device; lexmark_device; + lexmark_device = lexmark_device->next) + { + if (lexmark_device == handle) + break; + } + + if (lexmark_device->device_cancelled) + { + DBG (2, "sane_read: Device was cancelled\n"); + /* We don't know how far we've gone, so search for home. */ + sanei_lexmark_low_search_home_bwd (lexmark_device); + return SANE_STATUS_EOF; + } + + if (!length) + { + DBG (2, "sane_read: NULL length pointer\n"); + return SANE_STATUS_INVAL; + } + + *length = 0; + + if (lexmark_device->eof) + { + DBG (2, "sane_read: Trying to read past EOF\n"); + return SANE_STATUS_EOF; + } + + if (!data) + return SANE_STATUS_INVAL; + + bytes_read = sanei_lexmark_low_read_scan_data (data, max_length, + lexmark_device); + if (bytes_read < 0) + return SANE_STATUS_IO_ERROR; + else if (bytes_read == 0) + return SANE_STATUS_EOF; + else + { + *length = bytes_read; + lexmark_device->data_ctr += bytes_read; + } + + return SANE_STATUS_GOOD; +} + +void +sane_cancel (SANE_Handle handle) +{ + Lexmark_Device *lexmark_device; +/* ssize_t bytes_read; */ + DBG (2, "sane_cancel: handle = %p\n", (void *) handle); + + if (!initialized) + return; + + + for (lexmark_device = first_lexmark_device; lexmark_device; + lexmark_device = lexmark_device->next) + { + if (lexmark_device == handle) + break; + } + + /*If sane_cancel called more than once, return */ + if (++lexmark_device->cancel_ctr > 1) + return; + + /* Set the device flag so the next call to sane_read() can stop the scan. */ + lexmark_device->device_cancelled = SANE_TRUE; + + return; +} + +SANE_Status +sane_set_io_mode (SANE_Handle handle, SANE_Bool non_blocking) +{ + Lexmark_Device *lexmark_device; + + DBG (2, "sane_set_io_mode: handle = %p, non_blocking = %d\n", + (void *) handle, non_blocking); + + if (!initialized) + return SANE_STATUS_INVAL; + + for (lexmark_device = first_lexmark_device; lexmark_device; + lexmark_device = lexmark_device->next) + { + if (lexmark_device == handle) + break; + } + + if (non_blocking) + return SANE_STATUS_UNSUPPORTED; + + return SANE_STATUS_GOOD; +} + +SANE_Status +sane_get_select_fd (SANE_Handle handle, SANE_Int * fd) +{ + Lexmark_Device *lexmark_device; + + DBG (2, "sane_get_select_fd: handle = %p, fd %s 0\n", (void *) handle, + fd ? "!=" : "="); + + if (!initialized) + return SANE_STATUS_INVAL; + + for (lexmark_device = first_lexmark_device; lexmark_device; + lexmark_device = lexmark_device->next) + { + if (lexmark_device == handle) + break; + } + + return SANE_STATUS_UNSUPPORTED; +} + +/***************************** END OF SANE API ****************************/ +/* vim: set sw=2 cino=>2se-1sn-1s{s^-1st0(0u0 smarttab expandtab: */ |