diff options
Diffstat (limited to 'backend/p5.c')
| -rw-r--r-- | backend/p5.c | 2048 |
1 files changed, 2048 insertions, 0 deletions
diff --git a/backend/p5.c b/backend/p5.c new file mode 100644 index 0000000..30ab41e --- /dev/null +++ b/backend/p5.c @@ -0,0 +1,2048 @@ +/* sane - Scanner Access Now Easy. + + Copyright (C) 2009-12 Stéphane Voltz <stef.dev@free.fr> + + 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. +*/ +/* -------------------------------------------------------------------------- + +*/ + +/* ------------------------------------------------------------------------- */ +/*! \mainpage Primax PagePartner Parallel Port scanner Index Page + * + * \section intro_sec Introduction + * + * This backend provides support for the Prima PagePartner sheet fed parallel + * port scanner. + * + * \section sane_api SANE API + * + * \subsection sane_flow sane flow + SANE FLOW + - sane_init() : initialize backend, attach scanners. + - sane_get_devices() : query list of scanner devices, backend must + probe for new devices. + - sane_open() : open a particular scanner device, adding a handle + to the opened 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 for the ongoing scan + - sane_read() : read image data + - sane_cancel() : cancel operation, end scan + - sane_close() : close opened scanner device, freeing scanner handle + - sane_exit() : terminate use of backend, freeing all resources for attached + devices when last frontend quits + */ + +/** + * the build number allow to know which version of the backend is running. + */ +#define BUILD 2301 + +#include "p5.h" + +/** + * Import directly the low level part needed to + * operate scanner. The alternative is to prefix all public functions + * with sanei_p5_ ,and have all the functions prototyped in + * p5_device.h . + */ +#include "p5_device.c" + +/** + * number of time the backend has been loaded by sane_init. + */ +static int init_count = 0; + +/** + * NULL terminated list of opened frontend sessions. Sessions are + * inserted here on sane_open() and removed on sane_close(). + */ +static P5_Session *sessions = NULL; + +/** + * NULL terminated list of detected physical devices. + * The same device may be opened several time by different sessions. + * Entry are inserted here by the attach() function. + * */ +static P5_Device *devices = NULL; + +/** + * NULL terminated list of devices needed by sane_get_devices(), since + * the result returned must stay consistent until next call. + */ +static const SANE_Device **devlist = 0; + +/** + * list of possible color modes + */ +static SANE_String_Const mode_list[] = { + SANE_I18N (COLOR_MODE), + SANE_I18N (GRAY_MODE), + /* SANE_I18N (LINEART_MODE), not supported yet */ + 0 +}; + +static SANE_Range x_range = { + SANE_FIX (0.0), /* minimum */ + SANE_FIX (216.0), /* maximum */ + SANE_FIX (0.0) /* quantization */ +}; + +static SANE_Range y_range = { + SANE_FIX (0.0), /* minimum */ + SANE_FIX (299.0), /* maximum */ + SANE_FIX (0.0) /* no quantization */ +}; + +static const SANE_Range u8_range = { + 0, /* minimum */ + 255, /* maximum */ + 0 /* no quantization */ +}; + +static const SANE_Range threshold_percentage_range = { + SANE_FIX (0), /* minimum */ + SANE_FIX (100), /* maximum */ + SANE_FIX (1) /* quantization */ +}; + +/** + * finds the maximum string length in a string array. + */ +static size_t +max_string_size (const SANE_String_Const strings[]) +{ + size_t size, max_size = 0; + SANE_Int i; + + for (i = 0; strings[i]; ++i) + { + size = strlen (strings[i]) + 1; + if (size > max_size) + max_size = size; + } + return max_size; +} + +/**> placeholders for decoded configuration values */ +static P5_Config p5cfg; + + +/* ------------------------------------------------------------------------- */ + +/* + * SANE Interface + */ + + +/** + * Called by SANE initially. + * + * From the SANE spec: + * This function must be called before any other SANE function can be + * called. The behavior of a SANE backend is undefined if this + * function is not called first. The version code of the backend is + * returned in the value pointed to by version_code. If that pointer + * is NULL, no version code is returned. Argument authorize is either + * a pointer to a function that is invoked when the backend requires + * authentication for a specific resource or NULL if the frontend does + * not support authentication. + */ +SANE_Status +sane_init (SANE_Int * version_code, SANE_Auth_Callback authorize) +{ + SANE_Status status; + + authorize = authorize; /* get rid of compiler warning */ + + init_count++; + + /* init backend debug */ + DBG_INIT (); + DBG (DBG_info, "SANE P5 backend version %d.%d-%d\n", + SANE_CURRENT_MAJOR, V_MINOR, BUILD); + DBG (DBG_proc, "sane_init: start\n"); + DBG (DBG_trace, "sane_init: init_count=%d\n", init_count); + + if (version_code) + *version_code = SANE_VERSION_CODE (SANE_CURRENT_MAJOR, V_MINOR, BUILD); + + /* cold-plugging case : probe for already plugged devices */ + status = probe_p5_devices (); + + DBG (DBG_proc, "sane_init: exit\n"); + return status; +} + + +/** + * Called by SANE to find out about supported devices. + * + * From the SANE spec: + * This function can be used to query the list of devices that are + * available. If the function executes successfully, it stores a + * pointer to a NULL terminated array of pointers to SANE_Device + * structures in *device_list. The returned list is guaranteed to + * remain unchanged and valid until (a) another call to this function + * is performed or (b) a call to sane_exit() is performed. This + * function can be called repeatedly to detect when new devices become + * available. If argument local_only is true, only local devices are + * returned (devices directly attached to the machine that SANE is + * running on). If it is false, the device list includes all remote + * devices that are accessible to the SANE library. + * + * SANE does not require that this function is called before a + * sane_open() call is performed. A device name may be specified + * explicitly by a user which would make it unnecessary and + * undesirable to call this function first. + * @param device_list pointer where to store the device list + * @param local_only SANE_TRUE if only local devices are required. + * @return SANE_STATUS_GOOD when successfull + */ +SANE_Status +sane_get_devices (const SANE_Device *** device_list, SANE_Bool local_only) +{ + int dev_num, devnr; + struct P5_Device *device; + SANE_Device *sane_device; + int i; + + DBG (DBG_proc, "sane_get_devices: start: local_only = %s\n", + local_only == SANE_TRUE ? "true" : "false"); + + /* free existing devlist first */ + if (devlist) + { + for (i = 0; devlist[i] != NULL; i++) + free ((void *)devlist[i]); + free (devlist); + devlist = NULL; + } + + /** + * Since sane_get_devices() may be called repeatedly to detect new devices, + * the device detection must be run at each call. We are handling + * hot-plugging : we probe for devices plugged since sane_init() was called. + */ + probe_p5_devices (); + + /* if no devices detected, just return an empty list */ + if (devices == NULL) + { + devlist = malloc (sizeof (devlist[0])); + if (!devlist) + return SANE_STATUS_NO_MEM; + devlist[0] = NULL; + *device_list = devlist; + DBG (DBG_proc, "sane_get_devices: exit with no device\n"); + return SANE_STATUS_GOOD; + } + + /* count physical devices */ + devnr = 1; + device = devices; + while (device->next) + { + devnr++; + device = device->next; + } + + /* allocate room for the list, plus 1 for the NULL terminator */ + devlist = malloc ((devnr + 1) * sizeof (devlist[0])); + if (!devlist) + return SANE_STATUS_NO_MEM; + + *device_list = devlist; + + dev_num = 0; + device = devices; + + /* we build a list of SANE_Device from the list of attached devices */ + for (i = 0; i < devnr; i++) + { + /* add device according to local only flag */ + if ((local_only == SANE_TRUE && device->local == SANE_TRUE) + || local_only == SANE_FALSE) + { + /* allocate memory to add the device */ + sane_device = malloc (sizeof (*sane_device)); + if (!sane_device) + { + return SANE_STATUS_NO_MEM; + } + + /* copy data */ + sane_device->name = device->name; + sane_device->vendor = device->model->vendor; + sane_device->model = device->model->product; + sane_device->type = device->model->type; + devlist[dev_num] = sane_device; + + /* increment device counter */ + dev_num++; + } + + /* go to next detected device */ + device = device->next; + } + devlist[dev_num] = 0; + + *device_list = devlist; + + DBG (DBG_proc, "sane_get_devices: exit\n"); + + return SANE_STATUS_GOOD; +} + + +/** + * Called to establish connection with the session. This function will + * also establish meaningful defaults and initialize the options. + * + * From the SANE spec: + * This function is used to establish a connection to a particular + * device. The name of the device to be opened is passed in argument + * name. If the call completes successfully, a handle for the device + * is returned in *h. As a special case, specifying a zero-length + * string as the device requests opening the first available device + * (if there is such a device). Another special case is to only give + * the name of the backend as the device name, in this case the first + * available device will also be used. + * @param name name of the device to open + * @param handle opaque pointer where to store the pointer of + * the opened P5_Session + * @return SANE_STATUS_GOOD on success + */ +SANE_Status +sane_open (SANE_String_Const name, SANE_Handle * handle) +{ + struct P5_Session *session = NULL; + struct P5_Device *device = NULL; + + DBG (DBG_proc, "sane_open: start (devicename=%s)\n", name); + + /* check there is at least a device */ + if (devices == NULL) + { + DBG (DBG_proc, "sane_open: exit, no device to open!\n"); + return SANE_STATUS_INVAL; + } + + if (name[0] == 0 || strncmp (name, "p5", strlen ("p5")) == 0) + { + DBG (DBG_info, + "sane_open: no specific device requested, using default\n"); + if (devices) + { + device = devices; + DBG (DBG_info, "sane_open: device %s used as default device\n", + device->name); + } + } + else + { + DBG (DBG_info, "sane_open: device %s requested\n", name); + /* walk the device list until we find a matching name */ + device = devices; + while (device && strcmp (device->name, name) != 0) + { + DBG (DBG_trace, "sane_open: device %s doesn't match\n", + device->name); + device = device->next; + } + } + + /* check wether we have found a match or reach the end of the device list */ + if (!device) + { + DBG (DBG_info, "sane_open: no device found\n"); + return SANE_STATUS_INVAL; + } + + /* now we have a device, duplicate it and return it in handle */ + DBG (DBG_info, "sane_open: device %s found\n", name); + + /* device initialization */ + if (device->initialized == SANE_FALSE) + { + /** + * call to hardware initialization function here. + */ + device->fd = open_pp (device->name); + if (device->fd < 0) + { + DBG (DBG_error, "sane_open: failed to open '%s' device!\n", + device->name); + return SANE_STATUS_INVAL; + } + + /* now try to connect to scanner */ + if (connect (device->fd) != SANE_TRUE) + { + DBG (DBG_error, "sane_open: failed to connect!\n"); + close_pp (device->fd); + return SANE_STATUS_INVAL; + } + + /* load calibration data */ + restore_calibration (device); + + /* device link is OK now */ + device->initialized = SANE_TRUE; + } + device->buffer = NULL; + device->gain = NULL; + device->offset = NULL; + + /* prepare handle to return */ + session = (P5_Session *) malloc (sizeof (P5_Session)); + if (session == NULL) + { + DBG (DBG_proc, "sane_open: exit OOM\n"); + return SANE_STATUS_NO_MEM; + } + + /* initalize session */ + session->dev = device; + session->scanning = SANE_FALSE; + session->non_blocking = SANE_FALSE; + + /* initialize SANE options for this session */ + init_options (session); + + /* add the handle to the linked list of sessions */ + session->next = sessions; + sessions = session; + + /* store result */ + *handle = session; + + /* exit success */ + DBG (DBG_proc, "sane_open: exit\n"); + return SANE_STATUS_GOOD; +} + + +/** + * Set non blocking mode. In this mode, read return immediatly when + * no data is available whithin sane_read(), instead of polling the scanner. + */ +SANE_Status +sane_set_io_mode (SANE_Handle handle, SANE_Bool non_blocking) +{ + P5_Session *session = (P5_Session *) handle; + + DBG (DBG_proc, "sane_set_io_mode: start\n"); + if (session->scanning != SANE_TRUE) + { + DBG (DBG_error, "sane_set_io_mode: called out of a scan\n"); + return SANE_STATUS_INVAL; + } + session->non_blocking = non_blocking; + DBG (DBG_info, "sane_set_io_mode: I/O mode set to %sblocking.\n", + non_blocking ? "non " : " "); + DBG (DBG_proc, "sane_set_io_mode: exit\n"); + return SANE_STATUS_GOOD; +} + + +/** + * An advanced method we don't support but have to define. At SANE API + * level this function is meant to provide a file descriptor on which the + * frontend can do select()/poll() to wait for data. + */ +SANE_Status +sane_get_select_fd (SANE_Handle handle, SANE_Int * fdp) +{ + /* make compiler happy ... */ + handle = handle; + fdp = fdp; + + DBG (DBG_proc, "sane_get_select_fd: start\n"); + DBG (DBG_warn, "sane_get_select_fd: unsupported ...\n"); + DBG (DBG_proc, "sane_get_select_fd: exit\n"); + return SANE_STATUS_UNSUPPORTED; +} + + +/** + * Returns the options we know. + * + * From the SANE spec: + * This function is used to access option descriptors. The function + * returns the option descriptor for option number n of the device + * represented by handle h. Option number 0 is guaranteed to be a + * valid option. Its value is an integer that specifies the number of + * options that are available for device handle h (the count includes + * option 0). If n is not a valid option index, the function returns + * NULL. The returned option descriptor is guaranteed to remain valid + * (and at the returned address) until the device is closed. + */ +const SANE_Option_Descriptor * +sane_get_option_descriptor (SANE_Handle handle, SANE_Int option) +{ + struct P5_Session *session = handle; + + DBG (DBG_proc, "sane_get_option_descriptor: start\n"); + + if ((unsigned) option >= NUM_OPTIONS) + return NULL; + + DBG (DBG_info, "sane_get_option_descriptor: \"%s\"\n", + session->options[option].descriptor.name); + + DBG (DBG_proc, "sane_get_option_descriptor: exit\n"); + return &(session->options[option].descriptor); +} + +/** + * sets automatic value for an option , called by sane_control_option after + * all checks have been done */ +static SANE_Status +set_automatic_value (P5_Session * s, int option, SANE_Int * myinfo) +{ + SANE_Status status = SANE_STATUS_GOOD; + SANE_Int i, min; + SANE_Word *dpi_list; + + switch (option) + { + case OPT_TL_X: + s->options[OPT_TL_X].value.w = x_range.min; + *myinfo |= SANE_INFO_RELOAD_PARAMS; + break; + case OPT_TL_Y: + s->options[OPT_TL_Y].value.w = y_range.min; + *myinfo |= SANE_INFO_RELOAD_PARAMS; + break; + case OPT_BR_X: + s->options[OPT_BR_X].value.w = x_range.max; + *myinfo |= SANE_INFO_RELOAD_PARAMS; + break; + case OPT_BR_Y: + s->options[OPT_BR_Y].value.w = y_range.max; + *myinfo |= SANE_INFO_RELOAD_PARAMS; + break; + case OPT_RESOLUTION: + /* we set up to the lowest available dpi value */ + dpi_list = + (SANE_Word *) s->options[OPT_RESOLUTION].descriptor.constraint. + word_list; + min = 65536; + for (i = 1; i < dpi_list[0]; i++) + { + if (dpi_list[i] < min) + min = dpi_list[i]; + } + s->options[OPT_RESOLUTION].value.w = min; + *myinfo |= SANE_INFO_RELOAD_PARAMS; + break; + case OPT_PREVIEW: + s->options[OPT_PREVIEW].value.w = SANE_FALSE; + *myinfo |= SANE_INFO_RELOAD_PARAMS; + break; + case OPT_MODE: + if (s->options[OPT_MODE].value.s) + free (s->options[OPT_MODE].value.s); + s->options[OPT_MODE].value.s = strdup (mode_list[0]); + *myinfo |= SANE_INFO_RELOAD_OPTIONS; + *myinfo |= SANE_INFO_RELOAD_PARAMS; + break; + default: + DBG (DBG_warn, "set_automatic_value: can't set unknown option %d\n", + option); + } + + return status; +} + +/** + * sets an option , called by sane_control_option after all + * checks have been done */ +static SANE_Status +set_option_value (P5_Session * s, int option, void *val, SANE_Int * myinfo) +{ + SANE_Status status = SANE_STATUS_GOOD; + SANE_Word tmpw; + + switch (option) + { + case OPT_TL_X: + case OPT_BR_X: + case OPT_TL_Y: + case OPT_BR_Y: + s->options[option].value.w = *(SANE_Word *) val; + /* we ensure geometry is coherent */ + /* this happens when user drags TL corner right or below the BR point */ + if (s->options[OPT_BR_Y].value.w < s->options[OPT_TL_Y].value.w) + { + tmpw = s->options[OPT_BR_Y].value.w; + s->options[OPT_BR_Y].value.w = s->options[OPT_TL_Y].value.w; + s->options[OPT_TL_Y].value.w = tmpw; + } + if (s->options[OPT_BR_X].value.w < s->options[OPT_TL_X].value.w) + { + tmpw = s->options[OPT_BR_X].value.w; + s->options[OPT_BR_X].value.w = s->options[OPT_TL_X].value.w; + s->options[OPT_TL_X].value.w = tmpw; + } + + *myinfo |= SANE_INFO_RELOAD_PARAMS; + break; + + case OPT_RESOLUTION: + case OPT_PREVIEW: + s->options[option].value.w = *(SANE_Word *) val; + *myinfo |= SANE_INFO_RELOAD_PARAMS; + break; + + case OPT_MODE: + if (s->options[option].value.s) + free (s->options[option].value.s); + s->options[option].value.s = strdup (val); + *myinfo |= SANE_INFO_RELOAD_PARAMS | SANE_INFO_RELOAD_OPTIONS; + break; + + case OPT_CALIBRATE: + status = sheetfed_calibration (s->dev); + *myinfo |= SANE_INFO_RELOAD_OPTIONS; + break; + + case OPT_CLEAR_CALIBRATION: + cleanup_calibration (s->dev); + *myinfo |= SANE_INFO_RELOAD_OPTIONS; + break; + + default: + DBG (DBG_warn, "set_option_value: can't set unknown option %d\n", + option); + } + return status; +} + +/** + * gets an option , called by sane_control_option after all checks + * have been done */ +static SANE_Status +get_option_value (P5_Session * s, int option, void *val) +{ + SANE_Status status; + + switch (option) + { + /* word or word equivalent options: */ + case OPT_NUM_OPTS: + case OPT_RESOLUTION: + case OPT_PREVIEW: + case OPT_TL_X: + case OPT_TL_Y: + case OPT_BR_X: + case OPT_BR_Y: + *(SANE_Word *) val = s->options[option].value.w; + break; + + /* string options: */ + case OPT_MODE: + strcpy (val, s->options[option].value.s); + break; + + /* sensor options */ + case OPT_PAGE_LOADED_SW: + status = test_document (s->dev->fd); + if (status == SANE_STATUS_GOOD) + s->options[option].value.b = SANE_TRUE; + else + s->options[option].value.b = SANE_FALSE; + *(SANE_Bool *) val = s->options[option].value.b; + break; + + case OPT_NEED_CALIBRATION_SW: + *(SANE_Bool *) val = !s->dev->calibrated; + break; + + + /* unhandled options */ + default: + DBG (DBG_warn, "get_option_value: can't get unknown option %d\n", + option); + } + + return SANE_STATUS_GOOD; +} + +/** + * Gets or sets an option value. + * + * From the SANE spec: + * This function is used to set or inquire the current value of option + * number n of the device represented by handle h. The manner in which + * the option is controlled is specified by parameter action. The + * possible values of this parameter are described in more detail + * below. The value of the option is passed through argument val. It + * is a pointer to the memory that holds the option value. The memory + * area pointed to by v must be big enough to hold the entire option + * value (determined by member size in the corresponding option + * descriptor). + * + * The only exception to this rule is that when setting the value of a + * string option, the string pointed to by argument v may be shorter + * since the backend will stop reading the option value upon + * encountering the first NUL terminator in the string. If argument i + * is not NULL, the value of *i will be set to provide details on how + * well the request has been met. + * action is SANE_ACTION_GET_VALUE, SANE_ACTION_SET_VALUE or SANE_ACTION_SET_AUTO + */ +SANE_Status +sane_control_option (SANE_Handle handle, SANE_Int option, + SANE_Action action, void *val, SANE_Int * info) +{ + P5_Session *s = handle; + SANE_Status status; + SANE_Word cap; + SANE_Int myinfo = 0; + + DBG (DBG_io2, + "sane_control_option: start: action = %s, option = %s (%d)\n", + (action == SANE_ACTION_GET_VALUE) ? "get" : (action == + SANE_ACTION_SET_VALUE) ? + "set" : (action == SANE_ACTION_SET_AUTO) ? "set_auto" : "unknown", + s->options[option].descriptor.name, option); + + if (info) + *info = 0; + + /* do checks before trying to apply action */ + + if (s->scanning) + { + DBG (DBG_warn, "sane_control_option: don't call this function while " + "scanning (option = %s (%d))\n", + s->options[option].descriptor.name, option); + return SANE_STATUS_DEVICE_BUSY; + } + + /* option must be within existing range */ + if (option >= NUM_OPTIONS || option < 0) + { + DBG (DBG_warn, + "sane_control_option: option %d >= NUM_OPTIONS || option < 0\n", + option); + return SANE_STATUS_INVAL; + } + + /* don't access an inactive option */ + cap = s->options[option].descriptor.cap; + if (!SANE_OPTION_IS_ACTIVE (cap)) + { + DBG (DBG_warn, "sane_control_option: option %d is inactive\n", option); + return SANE_STATUS_INVAL; + } + + /* now checks have been done, apply action */ + switch (action) + { + case SANE_ACTION_GET_VALUE: + status = get_option_value (s, option, val); + break; + + case SANE_ACTION_SET_VALUE: + if (!SANE_OPTION_IS_SETTABLE (cap)) + { + DBG (DBG_warn, "sane_control_option: option %d is not settable\n", + option); + return SANE_STATUS_INVAL; + } + + status = + sanei_constrain_value (&s->options[option].descriptor, val, &myinfo); + if (status != SANE_STATUS_GOOD) + { + DBG (DBG_warn, + "sane_control_option: sanei_constrain_value returned %s\n", + sane_strstatus (status)); + return status; + } + + /* return immediatly if no change */ + if (s->options[option].descriptor.type == SANE_TYPE_INT + && *(SANE_Word *) val == s->options[option].value.w) + { + status = SANE_STATUS_GOOD; + } + else + { /* apply change */ + status = set_option_value (s, option, val, &myinfo); + } + break; + + case SANE_ACTION_SET_AUTO: + /* sets automatic values */ + if (!(cap & SANE_CAP_AUTOMATIC)) + { + DBG (DBG_warn, + "sane_control_option: option %d is not autosettable\n", + option); + return SANE_STATUS_INVAL; + } + + status = set_automatic_value (s, option, &myinfo); + break; + + default: + DBG (DBG_error, "sane_control_option: invalid action %d\n", action); + status = SANE_STATUS_INVAL; + break; + } + + if (info) + *info = myinfo; + + DBG (DBG_io2, "sane_control_option: exit\n"); + return status; +} + +/** + * Called by SANE when a page acquisition operation is to be started. + * @param handle opaque handle to a frontend session + * @return SANE_STATUS_GOOD on success, SANE_STATUS_BUSY if the device is + * in use by another session or SANE_STATUS_WARMING_UP if the device is + * warming up. In this case the fronted as to call sane_start again until + * warming up is done. Any other values returned are error status. + */ +SANE_Status +sane_start (SANE_Handle handle) +{ + struct P5_Session *session = handle; + int status = SANE_STATUS_GOOD; + P5_Device *dev = session->dev; + + DBG (DBG_proc, "sane_start: start\n"); + + /* if already scanning, tell we're busy */ + if (session->scanning == SANE_TRUE) + { + DBG (DBG_info, "sane_start: device is already scanning\n"); + return SANE_STATUS_DEVICE_BUSY; + } + + /* check that the device has been initialized */ + if (dev->initialized == SANE_FALSE) + { + DBG (DBG_error, "sane_start: device is not initialized\n"); + return SANE_STATUS_INVAL; + } + + /* check if there is a document */ + status = test_document (dev->fd); + if (status != SANE_STATUS_GOOD) + { + DBG (DBG_error, "sane_start: device is already scanning\n"); + return status; + } + + /* we compute all the scan parameters so that */ + /* we will be able to set up the registers correctly */ + compute_parameters (session); + + /* move to scan area if needed */ + if (dev->ystart > 0) + { + status = move (dev); + if (status != SANE_STATUS_GOOD) + { + DBG (DBG_error, "sane_start: failed to move to scan area\n"); + return SANE_STATUS_INVAL; + } + } + + /* send scan command */ + status = start_scan (dev, dev->mode, dev->ydpi, dev->xstart, dev->pixels); + if (status != SANE_STATUS_GOOD) + { + DBG (DBG_error, "sane_start: failed to start scan\n"); + return SANE_STATUS_INVAL; + } + + /* allocates work buffer */ + if (dev->buffer != NULL) + { + free (dev->buffer); + } + + dev->position = 0; + dev->top = 0; + /* compute amount of lines needed for lds correction */ + dev->bottom = dev->bytes_per_line * 2 * dev->lds; + /* computes buffer size, 66 color lines plus eventual amount needed for lds */ + dev->size = dev->pixels * 3 * 66 + dev->bottom; + dev->buffer = (uint8_t *) malloc (dev->size); + if (dev->buffer == NULL) + { + DBG (DBG_error, "sane_start: failed to allocate %lu bytes\n", (unsigned long)dev->size); + sane_cancel (handle); + return SANE_STATUS_NO_MEM; + } + + /* return now the scan has been initiated */ + session->scanning = SANE_TRUE; + session->sent = 0; + + DBG (DBG_io, "sane_start: to_send=%d\n", session->to_send); + DBG (DBG_io, "sane_start: size=%lu\n", (unsigned long)dev->size); + DBG (DBG_io, "sane_start: top=%lu\n", (unsigned long)dev->top); + DBG (DBG_io, "sane_start: bottom=%lu\n", (unsigned long)dev->bottom); + DBG (DBG_io, "sane_start: position=%lu\n", (unsigned long)dev->position); + + DBG (DBG_proc, "sane_start: exit\n"); + return status; +} + +/** @brief compute scan parameters + * This function computes two set of parameters. The one for the SANE's standard + * and the other for the hardware. Among these parameters are the bit depth, total + * number of lines, total number of columns, extra line to read for data reordering... + * @param session fronted session to compute final scan parameters + * @return SANE_STATUS_GOOD on success + */ +static SANE_Status +compute_parameters (P5_Session * session) +{ + P5_Device *dev = session->dev; + SANE_Int dpi; /* dpi for scan */ + SANE_String mode; + SANE_Status status = SANE_STATUS_GOOD; + + int tl_x, tl_y, br_x, br_y; + + mode = session->options[OPT_MODE].value.s; + dpi = session->options[OPT_RESOLUTION].value.w; + + /* scan coordinates */ + tl_x = SANE_UNFIX (session->options[OPT_TL_X].value.w); + tl_y = SANE_UNFIX (session->options[OPT_TL_Y].value.w); + br_x = SANE_UNFIX (session->options[OPT_BR_X].value.w); + br_y = SANE_UNFIX (session->options[OPT_BR_Y].value.w); + + /* only single pass scanning supported */ + session->params.last_frame = SANE_TRUE; + + /* gray modes */ + if (strcmp (mode, GRAY_MODE) == 0) + { + session->params.format = SANE_FRAME_GRAY; + dev->mode = MODE_GRAY; + dev->lds = 0; + } + else if (strcmp (mode, LINEART_MODE) == 0) + { + session->params.format = SANE_FRAME_GRAY; + dev->mode = MODE_LINEART; + dev->lds = 0; + } + else + { + /* Color */ + session->params.format = SANE_FRAME_RGB; + dev->mode = MODE_COLOR; + dev->lds = (dev->model->lds * dpi) / dev->model->max_ydpi; + } + + /* SANE level values */ + session->params.lines = ((br_y - tl_y) * dpi) / MM_PER_INCH; + if (session->params.lines == 0) + session->params.lines = 1; + session->params.pixels_per_line = ((br_x - tl_x) * dpi) / MM_PER_INCH; + if (session->params.pixels_per_line == 0) + session->params.pixels_per_line = 1; + + DBG (DBG_data, "compute_parameters: pixels_per_line =%d\n", + session->params.pixels_per_line); + + if (strcmp (mode, LINEART_MODE) == 0) + { + session->params.depth = 1; + /* in lineart, having pixels multiple of 8 avoids a costly test */ + /* at each bit to see we must go to the next byte */ + /* TODO : implement this requirement in sane_control_option */ + session->params.pixels_per_line = + ((session->params.pixels_per_line + 7) / 8) * 8; + } + else + session->params.depth = 8; + + /* width needs to be even */ + if (session->params.pixels_per_line & 1) + session->params.pixels_per_line++; + + /* Hardware settings : they can differ from the ones at SANE level */ + /* for instance the effective DPI used by a sensor may be higher */ + /* than the one needed for the SANE scan parameters */ + dev->lines = session->params.lines; + dev->pixels = session->params.pixels_per_line; + + /* motor and sensor DPI */ + dev->xdpi = dpi; + dev->ydpi = dpi; + + /* handle bounds of motor's dpi range */ + if (dev->ydpi > dev->model->max_ydpi) + { + dev->ydpi = dev->model->max_ydpi; + dev->lines = (dev->lines * dev->model->max_ydpi) / dpi; + if (dev->lines == 0) + dev->lines = 1; + + /* round number of lines */ + session->params.lines = + (session->params.lines / dev->lines) * dev->lines; + if (session->params.lines == 0) + session->params.lines = 1; + } + if (dev->ydpi < dev->model->min_ydpi) + { + dev->ydpi = dev->model->min_ydpi; + dev->lines = (dev->lines * dev->model->min_ydpi) / dpi; + } + + /* hardware values */ + dev->xstart = + ((SANE_UNFIX (dev->model->x_offset) + tl_x) * dpi) / MM_PER_INCH; + dev->ystart = + ((SANE_UNFIX (dev->model->y_offset) + tl_y) * dev->ydpi) / MM_PER_INCH; + + /* take lds correction into account when moving to scan area */ + if (dev->ystart > 2 * dev->lds) + dev->ystart -= 2 * dev->lds; + + + /* computes bytes per line */ + session->params.bytes_per_line = session->params.pixels_per_line; + dev->bytes_per_line = dev->pixels; + if (session->params.format == SANE_FRAME_RGB) + { + dev->bytes_per_line *= 3; + } + + /* in lineart mode we adjust bytes_per_line needed by frontend */ + /* we do that here because we needed sent/to_send to be as if */ + /* there was no lineart */ + if (session->params.depth == 1) + { + session->params.bytes_per_line = + (session->params.bytes_per_line + 7) / 8; + } + + session->params.bytes_per_line = dev->bytes_per_line; + session->to_send = session->params.bytes_per_line * session->params.lines; + session->params.bytes_per_line = dev->bytes_per_line; + + DBG (DBG_data, "compute_parameters: bytes_per_line =%d\n", + session->params.bytes_per_line); + DBG (DBG_data, "compute_parameters: depth =%d\n", + session->params.depth); + DBG (DBG_data, "compute_parameters: lines =%d\n", + session->params.lines); + DBG (DBG_data, "compute_parameters: image size =%d\n", + session->to_send); + + DBG (DBG_data, "compute_parameters: xstart =%d\n", dev->xstart); + DBG (DBG_data, "compute_parameters: ystart =%d\n", dev->ystart); + DBG (DBG_data, "compute_parameters: dev lines =%d\n", dev->lines); + DBG (DBG_data, "compute_parameters: dev bytes per line=%d\n", + dev->bytes_per_line); + DBG (DBG_data, "compute_parameters: dev pixels =%d\n", dev->pixels); + DBG (DBG_data, "compute_parameters: lds =%d\n", dev->lds); + + return status; +} + + +/** + * Called by SANE to retrieve information about the type of data + * that the current scan will return. + * + * From the SANE spec: + * This function is used to obtain the current scan parameters. The + * returned parameters are guaranteed to be accurate between the time + * a scan has been started (sane_start() has been called) and the + * completion of that request. Outside of that window, the returned + * values are best-effort estimates of what the parameters will be + * when sane_start() gets invoked. + * + * Calling this function before a scan has actually started allows, + * for example, to get an estimate of how big the scanned image will + * be. The parameters passed to this function are the handle of the + * device for which the parameters should be obtained and a pointer + * to a parameter structure. + */ +SANE_Status +sane_get_parameters (SANE_Handle handle, SANE_Parameters * params) +{ + SANE_Status status; + struct P5_Session *session = (struct P5_Session *) handle; + + DBG (DBG_proc, "sane_get_parameters: start\n"); + + /* call parameters computing function */ + status = compute_parameters (session); + if (status == SANE_STATUS_GOOD && params) + *params = session->params; + + DBG (DBG_proc, "sane_get_parameters: exit\n"); + return status; +} + + +/** + * Called by SANE to read data. + * + * From the SANE spec: + * This function is used to read image data from the device + * represented by handle h. Argument buf is a pointer to a memory + * area that is at least maxlen bytes long. The number of bytes + * returned is stored in *len. A backend must set this to zero when + * the call fails (i.e., when a status other than SANE_STATUS_GOOD is + * returned). + * + * When the call succeeds, the number of bytes returned can be + * anywhere in the range from 0 to maxlen bytes. + * + * Returned data is read from working buffer. + */ +SANE_Status +sane_read (SANE_Handle handle, SANE_Byte * buf, + SANE_Int max_len, SANE_Int * len) +{ + struct P5_Session *session = (struct P5_Session *) handle; + struct P5_Device *dev = session->dev; + SANE_Status status = SANE_STATUS_GOOD; + int count; + int size, lines; + SANE_Bool x2; + SANE_Int i; + + DBG (DBG_proc, "sane_read: start\n"); + DBG (DBG_io, "sane_read: up to %d bytes required by frontend\n", max_len); + + /* some sanity checks first to protect from would be buggy frontends */ + if (!session) + { + DBG (DBG_error, "sane_read: handle is null!\n"); + return SANE_STATUS_INVAL; + } + + if (!buf) + { + DBG (DBG_error, "sane_read: buf is null!\n"); + return SANE_STATUS_INVAL; + } + + if (!len) + { + DBG (DBG_error, "sane_read: len is null!\n"); + return SANE_STATUS_INVAL; + } + + /* no data read yet */ + *len = 0; + + /* check if session is scanning */ + if (!session->scanning) + { + DBG (DBG_warn, + "sane_read: scan was cancelled, is over or has not been initiated yet\n"); + return SANE_STATUS_CANCELLED; + } + + /* check for EOF, must be done before any physical read */ + if (session->sent >= session->to_send) + { + DBG (DBG_io, "sane_read: end of scan reached\n"); + return SANE_STATUS_EOF; + } + + /* if working buffer is empty, we do a physical data read */ + if (dev->top <= dev->bottom) + { + DBG (DBG_io, "sane_read: physical data read\n"); + /* check is there is data available. In case of non-blocking mode we return + * as soon it is detected there is no data yet. Reads must by done line by + * line, so we read only when count is bigger than bytes per line + * */ + count = available_bytes (dev->fd); + DBG (DBG_io, "sane_read: count=%d bytes\n", count); + if (count < dev->bytes_per_line && session->non_blocking == SANE_TRUE) + { + DBG (DBG_io, "sane_read: scanner hasn't enough data available\n"); + DBG (DBG_proc, "sane_read: exit\n"); + return SANE_STATUS_GOOD; + } + + /* now we can wait for data here */ + while (count < dev->bytes_per_line) + { + /* test if document left the feeder, so we have to terminate the scan */ + status = test_document (dev->fd); + if (status == SANE_STATUS_NO_DOCS) + { + session->to_send = session->sent; + return SANE_STATUS_EOF; + } + + /* don't call scanner too often */ + usleep (10000); + count = available_bytes (dev->fd); + } + + /** compute size of physical data to read + * on first read, position will be 0, while it will be 'bottom' + * for the subsequent reads. + * We try to read a complete buffer */ + size = dev->size - dev->position; + + if (session->to_send - session->sent < size) + { + /* not enough data left, so read remainder of scan */ + size = session->to_send - session->sent; + } + + /* 600 dpi is 300x600 physical, and 400 is 200x400 */ + if (dev->ydpi > dev->model->max_xdpi) + { + x2 = SANE_TRUE; + } + else + { + x2 = SANE_FALSE; + } + lines = read_line (dev, + dev->buffer + dev->position, + dev->bytes_per_line, + size / dev->bytes_per_line, + SANE_TRUE, x2, dev->mode, dev->calibrated); + + /* handle document end detection TODO try to recover the partial + * buffer already read before EOD */ + if (lines == -1) + { + DBG (DBG_io, "sane_read: error reading line\n"); + return SANE_STATUS_IO_ERROR; + } + + /* gather lines until we have more than needed for lds */ + dev->position += lines * dev->bytes_per_line; + dev->top = dev->position; + if (dev->position > dev->bottom) + { + dev->position = dev->bottom; + } + DBG (DBG_io, "sane_read: size =%lu\n", (unsigned long)dev->size); + DBG (DBG_io, "sane_read: bottom =%lu\n", (unsigned long)dev->bottom); + DBG (DBG_io, "sane_read: position=%lu\n", (unsigned long)dev->position); + DBG (DBG_io, "sane_read: top =%lu\n", (unsigned long)dev->top); + } /* end of physical data reading */ + + /* logical data reading */ + /* check if there data available in working buffer */ + if (dev->position < dev->top && dev->position >= dev->bottom) + { + DBG (DBG_io, "sane_read: logical data read\n"); + /* we have more data in internal buffer than asked , + * then send only max data */ + size = dev->top - dev->position; + if (max_len < size) + { + *len = max_len; + } + else + /* if we don't have enough, send all what we have */ + { + *len = dev->top - dev->position; + } + + /* data copy */ + if (dev->lds == 0) + { + memcpy (buf, dev->buffer + dev->position, *len); + } + else + { + /* compute count of bytes for lds */ + count = dev->lds * dev->bytes_per_line; + + /* adjust for lds as we copy data to frontend */ + for (i = 0; i < *len; i++) + { + switch ((dev->position + i) % 3) + { + /* red */ + case 0: + buf[i] = dev->buffer[dev->position + i - 2 * count]; + break; + /* green */ + case 1: + buf[i] = dev->buffer[dev->position + i - count]; + break; + /* blue */ + default: + buf[i] = dev->buffer[dev->position + i]; + break; + } + } + } + dev->position += *len; + + /* update byte accounting */ + session->sent += *len; + DBG (DBG_io, "sane_read: sent %d bytes from buffer to frontend\n", + *len); + return SANE_STATUS_GOOD; + } + + /* check if we exhausted working buffer */ + if (dev->position >= dev->top && dev->position >= dev->bottom) + { + /* copy extra lines needed for lds in next buffer */ + if (dev->position > dev->bottom && dev->lds > 0) + { + memcpy (dev->buffer, + dev->buffer + dev->position - dev->bottom, dev->bottom); + } + + /* restart buffer */ + dev->position = dev->bottom; + dev->top = 0; + } + + DBG (DBG_io, "sane_read: size =%lu\n", (unsigned long)dev->size); + DBG (DBG_io, "sane_read: bottom =%lu\n", (unsigned long)dev->bottom); + DBG (DBG_io, "sane_read: position=%lu\n", (unsigned long)dev->position); + DBG (DBG_io, "sane_read: top =%lu\n", (unsigned long)dev->top); + + DBG (DBG_proc, "sane_read: exit\n"); + return status; +} + + +/** + * Cancels a scan. + * + * From the SANE spec: + * This function is used to immediately or as quickly as possible + * cancel the currently pending operation of the device represented by + * handle h. This function can be called at any time (as long as + * handle h is a valid handle) but usually affects long-running + * operations only (such as image is acquisition). It is safe to call + * this function asynchronously (e.g., from within a signal handler). + * It is important to note that completion of this operaton does not + * imply that the currently pending operation has been cancelled. It + * only guarantees that cancellation has been initiated. Cancellation + * completes only when the cancelled call returns (typically with a + * status value of SANE_STATUS_CANCELLED). Since the SANE API does + * not require any other operations to be re-entrant, this implies + * that a frontend must not call any other operation until the + * cancelled operation has returned. + */ +void +sane_cancel (SANE_Handle handle) +{ + P5_Session *session = handle; + + DBG (DBG_proc, "sane_cancel: start\n"); + + /* if scanning, abort and park head */ + if (session->scanning == SANE_TRUE) + { + /* detects if we are called after the scan is finished, + * or if the scan is aborted */ + if (session->sent < session->to_send) + { + DBG (DBG_info, "sane_cancel: aborting scan.\n"); + /* device hasn't finished scan, we are aborting it + * and we may have to do something specific for it here */ + } + else + { + DBG (DBG_info, "sane_cancel: cleaning up after scan.\n"); + } + session->scanning = SANE_FALSE; + } + eject (session->dev->fd); + + DBG (DBG_proc, "sane_cancel: exit\n"); +} + + +/** + * Ends use of the session. + * + * From the SANE spec: + * This function terminates the association between the device handle + * passed in argument h and the device it represents. If the device is + * presently active, a call to sane_cancel() is performed first. After + * this function returns, handle h must not be used anymore. + * + * Handle resources are free'd before disposing the handle. But devices + * resources must not be mdofied, since it could be used or reused until + * sane_exit() is called. + */ +void +sane_close (SANE_Handle handle) +{ + P5_Session *prev, *session; + + DBG (DBG_proc, "sane_close: start\n"); + + /* remove handle from list of open handles: */ + prev = NULL; + for (session = sessions; session; session = session->next) + { + if (session == handle) + break; + prev = session; + } + if (!session) + { + DBG (DBG_error0, "close: invalid handle %p\n", handle); + return; /* oops, not a handle we know about */ + } + + /* cancel any active scan */ + if (session->scanning == SANE_TRUE) + { + sane_cancel (handle); + } + + if (prev) + prev->next = session->next; + else + sessions = session->next; + + /* close low level device */ + if (session->dev->initialized == SANE_TRUE) + { + if (session->dev->calibrated == SANE_TRUE) + { + save_calibration (session->dev); + } + disconnect (session->dev->fd); + close_pp (session->dev->fd); + session->dev->fd = -1; + session->dev->initialized = SANE_FALSE; + + /* free device data */ + if (session->dev->buffer != NULL) + { + free (session->dev->buffer); + } + if (session->dev->buffer != NULL) + { + free (session->dev->gain); + free (session->dev->offset); + } + if (session->dev->calibrated == SANE_TRUE) + { + cleanup_calibration (session->dev); + } + } + + /* free per session data */ + free (session->options[OPT_MODE].value.s); + free ((void *)session->options[OPT_RESOLUTION].descriptor.constraint.word_list); + + free (session); + + DBG (DBG_proc, "sane_close: exit\n"); +} + + +/** + * Terminates the backend. + * + * From the SANE spec: + * This function must be called to terminate use of a backend. The + * function will first close all device handles that still might be + * open (it is recommended to close device handles explicitly through + * a call to sane_close(), but backends are required to release all + * resources upon a call to this function). After this function + * returns, no function other than sane_init() may be called + * (regardless of the status value returned by sane_exit(). Neglecting + * to call this function may result in some resources not being + * released properly. + */ +void +sane_exit (void) +{ + struct P5_Session *session, *next; + struct P5_Device *dev, *nextdev; + int i; + + DBG (DBG_proc, "sane_exit: start\n"); + init_count--; + + if (init_count > 0) + { + DBG (DBG_info, + "sane_exit: still %d fronteds to leave before effective exit.\n", + init_count); + return; + } + + /* free session structs */ + for (session = sessions; session; session = next) + { + next = session->next; + sane_close ((SANE_Handle *) session); + free (session); + } + sessions = NULL; + + /* free devices structs */ + for (dev = devices; dev; dev = nextdev) + { + nextdev = dev->next; + free (dev->name); + free (dev); + } + devices = NULL; + + /* now list of devices */ + if (devlist) + { + i = 0; + while ((SANE_Device *) devlist[i]) + { + free ((SANE_Device *) devlist[i]); + i++; + } + free (devlist); + devlist = NULL; + } + + DBG (DBG_proc, "sane_exit: exit\n"); +} + + +/** @brief probe for all supported devices + * This functions tries to probe if any of the supported devices of + * the backend is present. Each detected device will be added to the + * 'devices' list + */ +static SANE_Status +probe_p5_devices (void) +{ + /**> configuration structure used during attach */ + SANEI_Config config; + /**> list of configuration options */ + SANE_Option_Descriptor *cfg_options[NUM_CFG_OPTIONS]; + /**> placeholders pointers for option values */ + void *values[NUM_CFG_OPTIONS]; + int i; + SANE_Status status; + + DBG (DBG_proc, "probe_p5_devices: start\n"); + + /* initialize configuration options */ + cfg_options[CFG_MODEL_NAME] = + (SANE_Option_Descriptor *) malloc (sizeof (SANE_Option_Descriptor)); + cfg_options[CFG_MODEL_NAME]->name = "modelname"; + cfg_options[CFG_MODEL_NAME]->desc = "user provided scanner's model name"; + cfg_options[CFG_MODEL_NAME]->type = SANE_TYPE_INT; + cfg_options[CFG_MODEL_NAME]->unit = SANE_UNIT_NONE; + cfg_options[CFG_MODEL_NAME]->size = sizeof (SANE_Word); + cfg_options[CFG_MODEL_NAME]->cap = SANE_CAP_SOFT_SELECT; + cfg_options[CFG_MODEL_NAME]->constraint_type = SANE_CONSTRAINT_NONE; + values[CFG_MODEL_NAME] = &p5cfg.modelname; + + /* set configuration options structure */ + config.descriptors = cfg_options; + config.values = values; + config.count = NUM_CFG_OPTIONS; + + /* generic configure and attach function */ + status = sanei_configure_attach (P5_CONFIG_FILE, &config, config_attach); + /* free allocated options */ + for (i = 0; i < NUM_CFG_OPTIONS; i++) + { + free (cfg_options[i]); + } + + DBG (DBG_proc, "probe_p5_devices: end\n"); + return status; +} + +/** This function is called by sanei_configure_attach to try + * to attach the backend to a device specified by the configuration file. + * + * @param config configuration structure filled with values read + * from configuration file + * @param devname name of the device to try to attach to, it is + * the unprocessed line of the configuration file + * + * @return status SANE_STATUS_GOOD if no errors (even if no matching + * devices found) + * SANE_STATUS_INVAL in case of error + */ +static SANE_Status +config_attach (SANEI_Config * config, const char *devname) +{ + /* currently, the config is a global variable so config is useless here */ + /* the correct thing would be to have a generic sanei_attach_matching_devices + * using an attach function with a config parameter */ + config = config; + + /* the devname has been processed and is ready to be used + * directly. The config struct contains all the configuration data for + * the corresponding device. Since there is no ressources common to each + * backends regarding parallel port, we can directly call the attach + * function. */ + attach_p5 (devname, config); + + return SANE_STATUS_GOOD; +} + +/** @brief try to attach to a device by its name + * The attach tries to open the given device and match it + * with devices handled by the backend. The configuration parameter + * contains the values of the already parsed configuration options + * from the conf file. + * @param config configuration structure filled with values read + * from configuration file + * @param devicename name of the device to try to attach to, it is + * the unprocessed line of the configuration file + * + * @return status SANE_STATUS_GOOD if no errors (even if no matching + * devices found) + * SANE_STATUS_NOM_MEM if there isn't enough memory to allocate the + * device structure + * SANE_STATUS_UNSUPPORTED if the device if unknown by the backend + * SANE_STATUS_INVAL in case of other error + */ +static SANE_Status +attach_p5 (const char *devicename, SANEI_Config * config) +{ + struct P5_Device *device; + struct P5_Model *model; + + DBG (DBG_proc, "attach(%s): start\n", devicename); + if(config==NULL) + { + DBG (DBG_warn, "attach: config is NULL\n"); + } + + /* search if we already have it attached */ + for (device = devices; device; device = device->next) + { + if (strcmp (device->name, devicename) == 0) + { + DBG (DBG_info, "attach: device already attached\n"); + DBG (DBG_proc, "attach: exit\n"); + return SANE_STATUS_GOOD; + } + } + + /** + * do physical probe of the device here. In case the device is recognized, + * we allocate a device struct and give it options and model. + * Else we return SANE_STATUS_UNSUPPORTED. + */ + model = probe (devicename); + if (model == NULL) + { + DBG (DBG_info, + "attach: device %s is not managed by the backend\n", devicename); + DBG (DBG_proc, "attach: exit\n"); + return SANE_STATUS_UNSUPPORTED; + } + + /* allocate device struct */ + device = malloc (sizeof (*device)); + if (device == NULL) + { + return SANE_STATUS_NO_MEM; + DBG (DBG_proc, "attach: exit\n"); + } + memset (device, 0, sizeof (*device)); + device->model = model; + + /* name of the device */ + device->name = strdup (devicename); + + DBG (DBG_info, "attach: found %s %s %s at %s\n", + device->model->vendor, device->model->product, device->model->type, + device->name); + + /* we insert new device at start of the chained list */ + /* head of the list becomes the next, and start is replaced */ + /* with the new session struct */ + device->next = devices; + devices = device; + + /* intialization is done at sane_open */ + device->initialized = SANE_FALSE; + device->calibrated = SANE_FALSE; + + DBG (DBG_proc, "attach: exit\n"); + return SANE_STATUS_GOOD; +} + + +/** @brief set initial value for the scanning options + * for each sessions, control options are initalized based on the capability + * of the model of the physical device. + * @param session scanner session to initialize options + * @return SANE_STATUS_GOOD on success + */ +static SANE_Status +init_options (struct P5_Session *session) +{ + SANE_Int option, i, min, idx; + SANE_Word *dpi_list; + P5_Model *model = session->dev->model; + + DBG (DBG_proc, "init_options: start\n"); + + /* we first initialize each options with a default value */ + memset (session->options, 0, sizeof (session->options[OPT_NUM_OPTS])); + for (option = 0; option < NUM_OPTIONS; option++) + { + session->options[option].descriptor.size = sizeof (SANE_Word); + session->options[option].descriptor.cap = + SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT; + } + + /* we set up all the options listed in the P5_Option enum */ + + /* last option / end of list marker */ + session->options[OPT_NUM_OPTS].descriptor.name = SANE_NAME_NUM_OPTIONS; + session->options[OPT_NUM_OPTS].descriptor.title = SANE_TITLE_NUM_OPTIONS; + session->options[OPT_NUM_OPTS].descriptor.desc = SANE_DESC_NUM_OPTIONS; + session->options[OPT_NUM_OPTS].descriptor.type = SANE_TYPE_INT; + session->options[OPT_NUM_OPTS].descriptor.cap = SANE_CAP_SOFT_DETECT; + session->options[OPT_NUM_OPTS].value.w = NUM_OPTIONS; + + /* "Standard" group: */ + session->options[OPT_STANDARD_GROUP].descriptor.title = SANE_TITLE_STANDARD; + session->options[OPT_STANDARD_GROUP].descriptor.name = SANE_NAME_STANDARD; + session->options[OPT_STANDARD_GROUP].descriptor.desc = SANE_DESC_STANDARD; + session->options[OPT_STANDARD_GROUP].descriptor.type = SANE_TYPE_GROUP; + session->options[OPT_STANDARD_GROUP].descriptor.size = 0; + session->options[OPT_STANDARD_GROUP].descriptor.cap = 0; + session->options[OPT_STANDARD_GROUP].descriptor.constraint_type = + SANE_CONSTRAINT_NONE; + + /* scan mode */ + session->options[OPT_MODE].descriptor.name = SANE_NAME_SCAN_MODE; + session->options[OPT_MODE].descriptor.title = SANE_TITLE_SCAN_MODE; + session->options[OPT_MODE].descriptor.desc = SANE_DESC_SCAN_MODE; + session->options[OPT_MODE].descriptor.type = SANE_TYPE_STRING; + session->options[OPT_MODE].descriptor.cap |= SANE_CAP_AUTOMATIC; + session->options[OPT_MODE].descriptor.constraint_type = + SANE_CONSTRAINT_STRING_LIST; + session->options[OPT_MODE].descriptor.size = max_string_size (mode_list); + session->options[OPT_MODE].descriptor.constraint.string_list = mode_list; + session->options[OPT_MODE].value.s = strdup (mode_list[0]); + + /* preview */ + session->options[OPT_PREVIEW].descriptor.name = SANE_NAME_PREVIEW; + session->options[OPT_PREVIEW].descriptor.title = SANE_TITLE_PREVIEW; + session->options[OPT_PREVIEW].descriptor.desc = SANE_DESC_PREVIEW; + session->options[OPT_PREVIEW].descriptor.type = SANE_TYPE_BOOL; + session->options[OPT_PREVIEW].descriptor.cap |= SANE_CAP_AUTOMATIC; + session->options[OPT_PREVIEW].descriptor.unit = SANE_UNIT_NONE; + session->options[OPT_PREVIEW].descriptor.constraint_type = + SANE_CONSTRAINT_NONE; + session->options[OPT_PREVIEW].value.w = SANE_FALSE; + + /** @brief build resolution list + * We merge xdpi and ydpi list to provide only one resolution option control. + * This is the most common case for backends and fronteds and give 'square' + * pixels. The SANE API allow to control x and y dpi independantly, but this is + * rarely done and may confuse both frontends and users. In case a dpi value exists + * for one but not for the other, the backend will have to crop data so that the + * frontend is unaffected. A common case is that motor resolution (ydpi) is higher + * than sensor resolution (xdpi), so scan lines must be scaled up to keep square + * pixel when doing sane_read(). + * TODO this deserves a dedicated function and some unit testing + */ + + /* find minimum first */ + min = 65535; + for (i = 0; i < MAX_RESOLUTIONS && model->xdpi_values[i] > 0; i++) + { + if (model->xdpi_values[i] < min) + min = model->xdpi_values[i]; + } + for (i = 0; i < MAX_RESOLUTIONS && model->ydpi_values[i] > 0; i++) + { + if (model->ydpi_values[i] < min) + min = model->ydpi_values[i]; + } + + dpi_list = malloc ((MAX_RESOLUTIONS * 2 + 1) * sizeof (SANE_Word)); + if (!dpi_list) + return SANE_STATUS_NO_MEM; + dpi_list[1] = min; + idx = 2; + + /* find any value greater than the last used min and + * less than the max value + */ + do + { + min = 65535; + for (i = 0; i < MAX_RESOLUTIONS && model->xdpi_values[i] > 0; i++) + { + if (model->xdpi_values[i] < min + && model->xdpi_values[i] > dpi_list[idx - 1]) + min = model->xdpi_values[i]; + } + for (i = 0; i < MAX_RESOLUTIONS && model->ydpi_values[i] > 0; i++) + { + if (model->ydpi_values[i] < min + && model->ydpi_values[i] > dpi_list[idx - 1]) + min = model->ydpi_values[i]; + } + if (min < 65535) + { + dpi_list[idx] = min; + idx++; + } + } + while (min != 65535); + dpi_list[idx] = 0; + /* the count of different resolution is put at the beginning */ + dpi_list[0] = idx - 1; + + session->options[OPT_RESOLUTION].descriptor.name = + SANE_NAME_SCAN_RESOLUTION; + session->options[OPT_RESOLUTION].descriptor.title = + SANE_TITLE_SCAN_RESOLUTION; + session->options[OPT_RESOLUTION].descriptor.desc = + SANE_DESC_SCAN_RESOLUTION; + session->options[OPT_RESOLUTION].descriptor.type = SANE_TYPE_INT; + session->options[OPT_RESOLUTION].descriptor.cap |= SANE_CAP_AUTOMATIC; + session->options[OPT_RESOLUTION].descriptor.unit = SANE_UNIT_DPI; + session->options[OPT_RESOLUTION].descriptor.constraint_type = + SANE_CONSTRAINT_WORD_LIST; + session->options[OPT_RESOLUTION].descriptor.constraint.word_list = dpi_list; + + /* initial value is lowest available dpi */ + session->options[OPT_RESOLUTION].value.w = min; + + /* "Geometry" group: */ + session->options[OPT_GEOMETRY_GROUP].descriptor.title = SANE_TITLE_GEOMETRY; + session->options[OPT_GEOMETRY_GROUP].descriptor.name = SANE_NAME_GEOMETRY; + session->options[OPT_GEOMETRY_GROUP].descriptor.desc = SANE_DESC_GEOMETRY; + session->options[OPT_GEOMETRY_GROUP].descriptor.type = SANE_TYPE_GROUP; + session->options[OPT_GEOMETRY_GROUP].descriptor.cap = SANE_CAP_ADVANCED; + session->options[OPT_GEOMETRY_GROUP].descriptor.size = 0; + session->options[OPT_GEOMETRY_GROUP].descriptor.constraint_type = + SANE_CONSTRAINT_NONE; + + /* adapt the constraint range to the detected model */ + x_range.max = model->x_size; + y_range.max = model->y_size; + + /* top-left x */ + session->options[OPT_TL_X].descriptor.name = SANE_NAME_SCAN_TL_X; + session->options[OPT_TL_X].descriptor.title = SANE_TITLE_SCAN_TL_X; + session->options[OPT_TL_X].descriptor.desc = SANE_DESC_SCAN_TL_X; + session->options[OPT_TL_X].descriptor.type = SANE_TYPE_FIXED; + session->options[OPT_TL_X].descriptor.cap |= SANE_CAP_AUTOMATIC; + session->options[OPT_TL_X].descriptor.unit = SANE_UNIT_MM; + session->options[OPT_TL_X].descriptor.constraint_type = + SANE_CONSTRAINT_RANGE; + session->options[OPT_TL_X].descriptor.constraint.range = &x_range; + session->options[OPT_TL_X].value.w = 0; + + /* top-left y */ + session->options[OPT_TL_Y].descriptor.name = SANE_NAME_SCAN_TL_Y; + session->options[OPT_TL_Y].descriptor.title = SANE_TITLE_SCAN_TL_Y; + session->options[OPT_TL_Y].descriptor.desc = SANE_DESC_SCAN_TL_Y; + session->options[OPT_TL_Y].descriptor.type = SANE_TYPE_FIXED; + session->options[OPT_TL_Y].descriptor.cap |= SANE_CAP_AUTOMATIC; + session->options[OPT_TL_Y].descriptor.unit = SANE_UNIT_MM; + session->options[OPT_TL_Y].descriptor.constraint_type = + SANE_CONSTRAINT_RANGE; + session->options[OPT_TL_Y].descriptor.constraint.range = &y_range; + session->options[OPT_TL_Y].value.w = 0; + + /* bottom-right x */ + session->options[OPT_BR_X].descriptor.name = SANE_NAME_SCAN_BR_X; + session->options[OPT_BR_X].descriptor.title = SANE_TITLE_SCAN_BR_X; + session->options[OPT_BR_X].descriptor.desc = SANE_DESC_SCAN_BR_X; + session->options[OPT_BR_X].descriptor.type = SANE_TYPE_FIXED; + session->options[OPT_BR_X].descriptor.cap |= SANE_CAP_AUTOMATIC; + session->options[OPT_BR_X].descriptor.unit = SANE_UNIT_MM; + session->options[OPT_BR_X].descriptor.constraint_type = + SANE_CONSTRAINT_RANGE; + session->options[OPT_BR_X].descriptor.constraint.range = &x_range; + session->options[OPT_BR_X].value.w = x_range.max; + + /* bottom-right y */ + session->options[OPT_BR_Y].descriptor.name = SANE_NAME_SCAN_BR_Y; + session->options[OPT_BR_Y].descriptor.title = SANE_TITLE_SCAN_BR_Y; + session->options[OPT_BR_Y].descriptor.desc = SANE_DESC_SCAN_BR_Y; + session->options[OPT_BR_Y].descriptor.type = SANE_TYPE_FIXED; + session->options[OPT_BR_Y].descriptor.cap |= SANE_CAP_AUTOMATIC; + session->options[OPT_BR_Y].descriptor.unit = SANE_UNIT_MM; + session->options[OPT_BR_Y].descriptor.constraint_type = + SANE_CONSTRAINT_RANGE; + session->options[OPT_BR_Y].descriptor.constraint.range = &y_range; + session->options[OPT_BR_Y].value.w = y_range.max; + + /* sensor group */ + session->options[OPT_SENSOR_GROUP].descriptor.name = SANE_NAME_SENSORS; + session->options[OPT_SENSOR_GROUP].descriptor.title = SANE_TITLE_SENSORS; + session->options[OPT_SENSOR_GROUP].descriptor.desc = SANE_DESC_SENSORS; + session->options[OPT_SENSOR_GROUP].descriptor.type = SANE_TYPE_GROUP; + session->options[OPT_SENSOR_GROUP].descriptor.constraint_type = + SANE_CONSTRAINT_NONE; + + /* page loaded sensor */ + session->options[OPT_PAGE_LOADED_SW].descriptor.name = + SANE_NAME_PAGE_LOADED; + session->options[OPT_PAGE_LOADED_SW].descriptor.title = + SANE_TITLE_PAGE_LOADED; + session->options[OPT_PAGE_LOADED_SW].descriptor.desc = + SANE_DESC_PAGE_LOADED; + session->options[OPT_PAGE_LOADED_SW].descriptor.type = SANE_TYPE_BOOL; + session->options[OPT_PAGE_LOADED_SW].descriptor.unit = SANE_UNIT_NONE; + session->options[OPT_PAGE_LOADED_SW].descriptor.cap = + SANE_CAP_SOFT_DETECT | SANE_CAP_HARD_SELECT | SANE_CAP_ADVANCED; + session->options[OPT_PAGE_LOADED_SW].value.b = 0; + + /* calibration needed */ + session->options[OPT_NEED_CALIBRATION_SW].descriptor.name = + "need-calibration"; + session->options[OPT_NEED_CALIBRATION_SW].descriptor.title = + SANE_I18N ("Need calibration"); + session->options[OPT_NEED_CALIBRATION_SW].descriptor.desc = + SANE_I18N ("The scanner needs calibration for the current settings"); + session->options[OPT_NEED_CALIBRATION_SW].descriptor.type = SANE_TYPE_BOOL; + session->options[OPT_NEED_CALIBRATION_SW].descriptor.unit = SANE_UNIT_NONE; + session->options[OPT_NEED_CALIBRATION_SW].descriptor.cap = + SANE_CAP_SOFT_DETECT | SANE_CAP_HARD_SELECT | SANE_CAP_ADVANCED; + session->options[OPT_NEED_CALIBRATION_SW].value.b = 0; + + /* button group */ + session->options[OPT_BUTTON_GROUP].descriptor.name = "Buttons"; + session->options[OPT_BUTTON_GROUP].descriptor.title = SANE_I18N ("Buttons"); + session->options[OPT_BUTTON_GROUP].descriptor.desc = SANE_I18N ("Buttons"); + session->options[OPT_BUTTON_GROUP].descriptor.type = SANE_TYPE_GROUP; + session->options[OPT_BUTTON_GROUP].descriptor.constraint_type = + SANE_CONSTRAINT_NONE; + + /* calibrate button */ + session->options[OPT_CALIBRATE].descriptor.name = "calibrate"; + session->options[OPT_CALIBRATE].descriptor.title = SANE_I18N ("Calibrate"); + session->options[OPT_CALIBRATE].descriptor.desc = + SANE_I18N ("Start calibration using special sheet"); + session->options[OPT_CALIBRATE].descriptor.type = SANE_TYPE_BUTTON; + session->options[OPT_CALIBRATE].descriptor.unit = SANE_UNIT_NONE; + session->options[OPT_CALIBRATE].descriptor.cap = + SANE_CAP_SOFT_DETECT | SANE_CAP_SOFT_SELECT | SANE_CAP_ADVANCED | + SANE_CAP_AUTOMATIC; + session->options[OPT_CALIBRATE].value.b = 0; + + /* clear calibration cache button */ + session->options[OPT_CLEAR_CALIBRATION].descriptor.name = "clear"; + session->options[OPT_CLEAR_CALIBRATION].descriptor.title = + SANE_I18N ("Clear calibration"); + session->options[OPT_CLEAR_CALIBRATION].descriptor.desc = + SANE_I18N ("Clear calibration cache"); + session->options[OPT_CLEAR_CALIBRATION].descriptor.type = SANE_TYPE_BUTTON; + session->options[OPT_CLEAR_CALIBRATION].descriptor.unit = SANE_UNIT_NONE; + session->options[OPT_CLEAR_CALIBRATION].descriptor.cap = + SANE_CAP_SOFT_DETECT | SANE_CAP_SOFT_SELECT | SANE_CAP_ADVANCED | + SANE_CAP_AUTOMATIC; + session->options[OPT_CLEAR_CALIBRATION].value.b = 0; + + /* until work on calibration isfinished */ + DISABLE (OPT_CALIBRATE); + DISABLE (OPT_CLEAR_CALIBRATION); + + DBG (DBG_proc, "init_options: exit\n"); + return SANE_STATUS_GOOD; +} + +/** @brief physical probe of a device + * This function probes for a scanning device using the given name. If the + * device is managed, a model structure describing the device will be returned. + * @param devicename low level device to access to probe hardware + * @return NULL is the device is unsupported, or a model struct describing the + * device. + */ +P5_Model * +probe (const char *devicename) +{ + int fd; + + /* open parallel port device */ + fd = open_pp (devicename); + if (fd < 0) + { + DBG (DBG_error, "probe: failed to open '%s' device!\n", devicename); + return NULL; + } + + /* now try to connect to scanner */ + if (connect (fd) != SANE_TRUE) + { + DBG (DBG_error, "probe: failed to connect!\n"); + close_pp (fd); + return NULL; + } + + /* set up for memory test */ + write_reg (fd, REG1, 0x00); + write_reg (fd, REG7, 0x00); + write_reg (fd, REG0, 0x00); + write_reg (fd, REG1, 0x00); + write_reg (fd, REGF, 0x80); + if (memtest (fd, 0x0100) != SANE_TRUE) + { + disconnect (fd); + close_pp (fd); + DBG (DBG_error, "probe: memory test failed!\n"); + return NULL; + } + else + { + DBG (DBG_info, "memtest() OK...\n"); + } + write_reg (fd, REG7, 0x00); + + /* check for document presence 0xC6: present, 0xC3 no document */ + test_document (fd); + + /* release device nd parport for next uses */ + disconnect (fd); + close_pp (fd); + + /* for there is only one supported model, so we use hardcoded values */ + DBG (DBG_proc, "probe: exit\n"); + return &pagepartner_model; +} + + +/* vim: set sw=2 cino=>2se-1sn-1s{s^-1st0(0u0 smarttab expandtab: */ |