summaryrefslogtreecommitdiff
path: root/backend/canon_pp.c
diff options
context:
space:
mode:
authorJörg Frings-Fürst <debian@jff-webhosting.net>2014-10-06 14:00:40 +0200
committerJörg Frings-Fürst <debian@jff-webhosting.net>2014-10-06 14:00:40 +0200
commit6e9c41a892ed0e0da326e0278b3221ce3f5713b8 (patch)
tree2e301d871bbeeb44aa57ff9cc070fcf3be484487 /backend/canon_pp.c
Initial import of sane-backends version 1.0.24-1.2
Diffstat (limited to 'backend/canon_pp.c')
-rw-r--r--backend/canon_pp.c2039
1 files changed, 2039 insertions, 0 deletions
diff --git a/backend/canon_pp.c b/backend/canon_pp.c
new file mode 100644
index 0000000..cc7c27e
--- /dev/null
+++ b/backend/canon_pp.c
@@ -0,0 +1,2039 @@
+/* sane - Scanner Access Now Easy.
+ Copyright (C) 2001-2002 Matthew C. Duggan and Simon Krix
+ 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.
+
+ -----
+
+ canon_pp.c: $Revision$
+
+ This file is part of the canon_pp backend, supporting Canon FBX30P
+ and NX40P scanners
+ */
+
+#ifdef _AIX
+#include <lalloca.h> /* MUST come first for AIX! */
+#endif
+
+#define BACKEND_NAME canon_pp
+
+#define THREE_BITS 0xE0
+#define TWO_BITS 0xC0
+#define MM_PER_IN 25.4
+
+#ifndef NOSANE
+#include "../include/sane/config.h"
+#endif
+
+#ifndef VERSION
+#define VERSION "$Revision$"
+#endif
+
+#include <string.h>
+#include <math.h>
+#include <unistd.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <ieee1284.h>
+
+#include "../include/sane/sane.h"
+#include "../include/sane/saneopts.h"
+
+#include "canon_pp-dev.h"
+#include "canon_pp-io.h"
+#include "canon_pp.h"
+
+/* #include "../include/sane/sanei_pio.h" */
+#include "../include/sane/sanei_config.h"
+#include "../include/sane/sanei_backend.h"
+/* #include "../include/sane/sanei_debug.h" */
+
+
+/* Prototypes */
+static SANE_Status init_device(struct parport *pp);
+
+/* create a calibration file and give it initial values */
+static int init_cal(char *file);
+
+static SANE_Status fix_weights_file(CANONP_Scanner *cs);
+
+static SANE_Status detect_mode(CANONP_Scanner *cs);
+
+/* Global Variables (ack!) */
+
+/* The first device in a linked list of devices */
+static CANONP_Scanner *first_dev = NULL;
+/* The default scanner to open */
+static char *def_scanner = NULL;
+/* The number of devices */
+static int num_devices = 0;
+/* ieee1284 parallel ports */
+struct parport_list pl;
+/* leftover from the last read */
+static SANE_Byte *read_leftover = NULL;
+/* leftover from the last read */
+static SANE_Bool force_nibble = SANE_FALSE;
+
+/* Constants */
+
+/* Colour Modes */
+static const SANE_String_Const cmodes[] = {
+ SANE_VALUE_SCAN_MODE_GRAY,
+ SANE_VALUE_SCAN_MODE_COLOR,
+ NULL };
+
+/* bit depths */
+static const SANE_String_Const depths[] = { "8", "12", NULL };
+/* resolutions */
+static const SANE_Int res300[] = {3, 75, 150, 300};
+static const SANE_Int res600[] = {4, 75, 150, 300, 600};
+
+
+/*************************************************************************
+ *
+ * sane_init()
+ *
+ * Initialises data for the list of scanners, stored in canon-p.conf.
+ *
+ * Scanners are not sent any commands until sane_open() is called.
+ *
+ *************************************************************************/
+ SANE_Status
+sane_init (SANE_Int *vc, SANE_Auth_Callback cb)
+{
+ SANE_Status status = SANE_STATUS_GOOD;
+ int i, tmp;
+ int tmp_im = INITMODE_AUTO;
+ FILE *fp;
+ char line[81]; /* plus 1 for a null */
+ char *tmp_wf, *tmp_port;
+ CANONP_Scanner *s_tmp;
+
+
+ DBG_INIT();
+
+#if defined PACKAGE && defined VERSION
+ DBG(2, ">> sane_init (version %s null, authorize %s null): " PACKAGE " " VERSION "\n",
+ (vc) ? "!=" : "==", (cb) ? "!=" : "==");
+#endif
+
+ if(vc)
+ *vc = SANE_VERSION_CODE (SANE_CURRENT_MAJOR, V_MINOR, 0);
+
+ DBG(2,"sane_init: >> ieee1284_find_ports\n");
+ /* Find lp ports */
+ tmp = ieee1284_find_ports(&pl, 0);
+ DBG(2,"sane_init: %d << ieee1284_find_ports\n", tmp);
+
+ if (tmp != E1284_OK)
+ {
+ DBG(1,"sane_init: Error trying to get port list\n");
+ return SANE_STATUS_IO_ERROR;
+ }
+
+
+ if (pl.portc < 1)
+ {
+ DBG(1,"sane_init: Error, no parallel ports found.\n");
+ return SANE_STATUS_IO_ERROR;
+ }
+
+ DBG(10,"sane_init: %i parallel port(s) found.\n", pl.portc);
+ /* Setup data structures for each port */
+ for(i=0; i<pl.portc; i++)
+ {
+ DBG(10,"sane_init: port %s\n", pl.portv[i]->name);
+ status = init_device(pl.portv[i]);
+ /* Now's a good time to quit if we got an error */
+ if (status != SANE_STATUS_GOOD) return status;
+ }
+
+ /* This should never be true here */
+ if (num_devices == 0)
+ status = SANE_STATUS_IO_ERROR;
+
+ /* just to be extra sure, the line will always have an end: */
+ line[sizeof(line)-1] = '\0';
+
+ /*
+ * Read information from config file: pixel weight location and default
+ * port.
+ */
+ if((fp = sanei_config_open(CANONP_CONFIG_FILE)))
+ {
+ while(sanei_config_read(line, sizeof (line) - 1, fp))
+ {
+ DBG(100, "sane_init: >%s<\n", line);
+ if(line[0] == '#') /* ignore line comments */
+ continue;
+ if(!strlen(line))
+ continue; /* ignore empty lines */
+
+ if(strncmp(line,"calibrate ", 10) == 0)
+ {
+ /* warning: pointer trickyness ahead
+ * Do not free tmp_port! */
+ DBG(40, "sane_init: calibrate line, %s\n",
+ line);
+ tmp_wf = strdup(line+10);
+ tmp_port = strstr(tmp_wf, " ");
+ if ((tmp_port == tmp_wf) || (tmp_port == NULL))
+ {
+ /* They have used an old style config
+ * file which does not specify scanner
+ * Assume first port */
+ DBG(1, "sane_init: old config line:"
+ "\"%s\". Please add "
+ "a port argument.\n",
+ line);
+
+ /* first_dev should never be null here
+ * because we found at least one
+ * parallel port above */
+ first_dev->weights_file = tmp_wf;
+ DBG(100, "sane_init: Successfully "
+ "parsed (old) cal, "
+ "weight file is "
+ "'%s'.\n", tmp_wf);
+ continue;
+
+ }
+
+ /* Now find which scanner wants
+ * this calibration file */
+ s_tmp = first_dev;
+ DBG(100, "sane_init: Finding scanner on port "
+ "'%s'\n", tmp_port+1);
+ while (s_tmp != NULL)
+ {
+ if (!strcmp(s_tmp->params.port->name,
+ tmp_port+1))
+ {
+ DBG(100, "sane_init: Found!\n");
+ /* Now terminate the weight
+ * file string */
+ *tmp_port = '\0';
+ s_tmp->weights_file = tmp_wf;
+ DBG(100, "sane_init: Parsed "
+ "cal, for port"
+ " '%s', weight"
+ " file is '%s'"
+ ".\n",
+ s_tmp->params.
+ port->name,
+ tmp_wf);
+ break;
+ }
+ s_tmp = s_tmp->next;
+ }
+ if (s_tmp == NULL)
+ {
+ /* we made it all the way through the
+ * list and didn't find the port */
+ free(tmp_wf);
+ DBG(10, "sane_init: calibrate line is "
+ "for unknown port!\n");
+ }
+ continue;
+ }
+
+
+ if(strncmp(line,"ieee1284 ", 9) == 0)
+ {
+ DBG(100, "sane_init: Successfully parsed "
+ "default scanner.\n");
+ /* this will be our default scanner */
+ def_scanner = strdup(line+9);
+ continue;
+ }
+
+ if(strncmp(line,"force_nibble", 12) == 0)
+ {
+ DBG(100, "sane_init: force_nibble "
+ "requested.\n");
+ force_nibble = SANE_TRUE;
+ continue;
+ }
+
+ if(strncmp(line,"init_mode ", 10) == 0)
+ {
+
+ /* parse what sort of initialisation mode to
+ * use */
+ if (strncmp(line+10, "FB620P", 6) == 0)
+ tmp_im = INITMODE_20P;
+ else if (strncmp(line+10, "FB630P", 6) == 0)
+ tmp_im = INITMODE_30P;
+ else if (strncmp(line+10, "AUTO", 4) == 0)
+ tmp_im = INITMODE_AUTO;
+
+ /* now work out which port it blongs to */
+
+ tmp_port = strstr(line+10, " ");
+
+ if (tmp_port == NULL)
+ {
+ /* first_dev should never be null here
+ * because we found at least one
+ * parallel port above */
+ first_dev->init_mode = tmp_im;
+ DBG(100, "sane_init: Parsed init-1.\n");
+ continue;
+ }
+
+
+ s_tmp = first_dev;
+ while (s_tmp != NULL)
+ {
+ if (!strcmp(s_tmp->params.port->name,
+ tmp_port+1))
+ {
+ s_tmp->init_mode = tmp_im;
+ DBG(100, "sane_init: Parsed "
+ "init.\n");
+ break;
+ }
+ s_tmp = s_tmp->next;
+ }
+ if (s_tmp == NULL)
+ {
+ /* we made it all the way through the
+ * list and didn't find the port */
+ DBG(10, "sane_init: init_mode line is "
+ "for unknown port!\n");
+ }
+
+ continue;
+ }
+ DBG(1, "sane_init: Unknown configuration command!");
+
+ }
+ fclose (fp);
+ }
+
+ /* There should now be a LL of ports starting at first_dev */
+
+ for (s_tmp = first_dev; s_tmp != NULL; s_tmp = s_tmp->next)
+ {
+ /* Assume there's no scanner present until proven otherwise */
+ s_tmp->scanner_present = SANE_FALSE;
+
+ /* Try to detect if there's a scanner there, and if so,
+ * what sort of scanner it is */
+ status = detect_mode(s_tmp);
+
+ if (status != SANE_STATUS_GOOD)
+ {
+ DBG(10,"sane_init: Error detecting port mode on %s!\n",
+ s_tmp->params.port->name);
+ s_tmp->scanner_present = SANE_FALSE;
+ continue;
+ }
+
+ /* detect_mode suceeded, so the port is open. This beholdens
+ * us to call ieee1284_close in any of the remaining error
+ * cases in this loop. */
+#if 0
+ tmp = sanei_canon_pp_detect(s_tmp->params.port,
+ s_tmp->init_mode);
+
+
+ if (tmp && (s_tmp->ieee1284_mode != M1284_NIBBLE))
+ {
+ /* A failure, try again in nibble mode... */
+ DBG(1, "sane_init: Failed on ECP mode, falling "
+ "back to nibble mode\n");
+
+ s_tmp->ieee1284_mode = M1284_NIBBLE;
+ sanei_canon_pp_set_ieee1284_mode(s_tmp->ieee1284_mode);
+ tmp = sanei_canon_pp_detect(s_tmp->params.port,
+ s_tmp->init_mode);
+ }
+ /* still no go? */
+ if (tmp)
+ {
+ DBG(1,"sane_init: couldn't find a scanner on port "
+ "%s\n", s_tmp->params.port->name);
+
+ ieee1284_close(s_tmp->params.port);
+ continue;
+ }
+
+#endif
+ /* all signs point to yes, try it out */
+ if (ieee1284_claim(s_tmp->params.port) != E1284_OK) {
+ DBG(10, "sane_init: Couldn't claim port %s.\n",
+ s_tmp->params.port->name);
+
+ ieee1284_close(s_tmp->params.port);
+ continue;
+ }
+
+ DBG(2, "sane_init: >> initialise\n");
+ tmp = sanei_canon_pp_initialise(&(s_tmp->params),
+ s_tmp->init_mode);
+ DBG(2, "sane_init: << %d initialise\n", tmp);
+ if (tmp) {
+ DBG(10, "sane_init: Couldn't contact scanner on port "
+ "%s. Probably no scanner there?\n",
+ s_tmp->params.port->name);
+ ieee1284_release(s_tmp->params.port);
+ ieee1284_close(s_tmp->params.port);
+ s_tmp->scanner_present = SANE_FALSE;
+ continue;
+ }
+
+ /* put it back to sleep until we're ready to
+ * open for business again - this will only work
+ * if we actually have a scanner there! */
+ DBG(100, "sane_init: And back to sleep again\n");
+ sanei_canon_pp_sleep_scanner(s_tmp->params.port);
+
+ /* leave the port open but not claimed - this is regardless
+ * of the return value of initialise */
+ ieee1284_release(s_tmp->params.port);
+
+ /* Finally, we're sure there's a scanner there! Now we
+ * just have to load the weights file...*/
+
+ if (fix_weights_file(s_tmp) != SANE_STATUS_GOOD) {
+ DBG(1, "sane_init: Eeek! fix_weights_file failed for "
+ "scanner on port %s!\n",
+ s_tmp->params.port->name);
+ /* non-fatal.. scans will look ugly as sin unless
+ * they calibrate */
+ }
+
+ /* Cocked, locked and ready to rock */
+ s_tmp->hw.model = s_tmp->params.name;
+ s_tmp->scanner_present = SANE_TRUE;
+ }
+
+ DBG(2, "<< sane_init\n");
+
+ return status;
+}
+
+
+/*************************************************************************
+ *
+ * sane_get_devices()
+ *
+ * Gives a list of devices avaialable. In our case, that's the linked
+ * list produced by sane_init.
+ *
+ *************************************************************************/
+ SANE_Status
+sane_get_devices (const SANE_Device ***dl, SANE_Bool local)
+{
+ static const SANE_Device **devlist;
+ CANONP_Scanner *dev;
+ int i;
+
+ DBG(2, ">> sane_get_devices (%p, %d)\n", (const void*)dl, local);
+
+ if (dl == NULL)
+ {
+ DBG(1, "sane_get_devices: ERROR: devlist pointer is NULL!");
+ return SANE_STATUS_INVAL;
+ }
+
+ if (devlist != NULL)
+ {
+ /* this has been called already */
+ *dl = devlist;
+ return SANE_STATUS_GOOD;
+ }
+ devlist = malloc((num_devices + 1) * sizeof(*devlist));
+ if (devlist == NULL)
+ return SANE_STATUS_NO_MEM;
+
+ i = 0;
+ for (dev = first_dev; dev != NULL; dev = dev->next)
+ {
+ if (dev->scanner_present == SANE_TRUE)
+ {
+ devlist[i] = &(dev->hw);
+ i++;
+ }
+ }
+
+ devlist[i] = NULL;
+
+ *dl = devlist;
+
+ DBG(2, "<< sane_get_devices\n");
+ return SANE_STATUS_GOOD;
+}
+
+
+/*************************************************************************
+ *
+ * sane_open()
+ *
+ * Open the scanner described by name. Ask libieee1284 to claim the port
+ * and call Simon's init code. Also configure data structures.
+ *
+ *************************************************************************/
+ SANE_Status
+sane_open (SANE_String_Const name, SANE_Handle *h)
+{
+ CANONP_Scanner *cs;
+ SANE_Range *tmp_range;
+ int tmp;
+
+ DBG(2, ">> sane_open (h=%p, name=\"%s\")\n", (void *)h, name);
+
+ if ((h == NULL) || (name == NULL))
+ {
+ DBG(2,"sane_open: Null pointer received!\n");
+ return SANE_STATUS_INVAL;
+ }
+
+ if (!strlen(name))
+ {
+ DBG(10,"sane_open: Empty name given, assuming first/"
+ "default scanner\n");
+ if (def_scanner == NULL)
+ name = first_dev->params.port->name;
+ else
+ name = def_scanner;
+
+ /* we don't _have_ to fit this name, so _don't_ fail if it's
+ * not there */
+
+ cs = first_dev;
+ while((cs != NULL) && strcmp(cs->params.port->name, name))
+ cs = cs->next;
+
+ /* if we didn't find the port they want, or there's no scanner
+ * there, we just want to find _any_ scanner */
+ if ((cs == NULL) || (cs->scanner_present != SANE_TRUE))
+ {
+ cs = first_dev;
+ while((cs != NULL) &&
+ (cs->scanner_present == SANE_FALSE))
+ cs = cs->next;
+ }
+
+ } else {
+
+ /* they're dead keen for this name, so _do_ fail if it's
+ * not there */
+ cs = first_dev;
+ while((cs != NULL) && strcmp(cs->params.port->name, name))
+ cs = cs->next;
+ }
+
+
+ if (cs == NULL)
+ {
+ DBG(2,"sane_open: No scanner found or requested port "
+ "doesn't exist (%s)\n", name);
+ return SANE_STATUS_IO_ERROR;
+ }
+ if (cs->scanner_present == SANE_FALSE)
+ {
+ DBG(1,"sane_open: Request to open port with no scanner "
+ "(%s)\n", name);
+ return SANE_STATUS_IO_ERROR;
+ }
+ if (cs->opened == SANE_TRUE)
+ {
+ DBG(2,"sane_open; Oi!, That scanner's already open.\n");
+ return SANE_STATUS_DEVICE_BUSY;
+ }
+
+ /* If the scanner has already been opened once, we don't have to do
+ * this setup again */
+ if (cs->setup == SANE_TRUE)
+ {
+ cs->opened = SANE_TRUE;
+ *h = (SANE_Handle)cs;
+ return SANE_STATUS_GOOD;
+ }
+
+ tmp = ieee1284_claim(cs->params.port);
+ if (tmp != E1284_OK) {
+ DBG(1, "sane_open: Could not claim port!\n");
+ return SANE_STATUS_IO_ERROR;
+ }
+
+ /* I put the scanner to sleep before, better wake it back up */
+
+ DBG(2, "sane_open: >> initialise\n");
+ tmp = sanei_canon_pp_initialise(&(cs->params), cs->init_mode);
+ DBG(2, "sane_open: << %d initialise\n", tmp);
+ if (tmp != 0) {
+ DBG(1, "sane_open: initialise returned %d, something is "
+ "wrong with the scanner!\n", tmp);
+
+ DBG(1, "sane_open: Can't contact scanner. Try power "
+ "cycling scanner, and unplug any "
+ "printers\n");
+ ieee1284_release(cs->params.port);
+ return SANE_STATUS_IO_ERROR;
+ }
+
+ if (cs->weights_file != NULL)
+ DBG(2, "sane_open: >> load_weights(%s, %p)\n",
+ cs->weights_file,
+ (const void *)(&(cs->params)));
+ else
+ DBG(2, "sane_open: >> load_weights(NULL, %p)\n",
+ (const void *)(&(cs->params)));
+ tmp = sanei_canon_pp_load_weights(cs->weights_file, &(cs->params));
+ DBG(2, "sane_open: << %d load_weights\n", tmp);
+
+ if (tmp != 0) {
+ DBG(1, "sane_open: WARNING: Error on load_weights: "
+ "returned %d. This could be due to a corrupt "
+ "calibration file. Try recalibrating and if "
+ "problems persist, please report the problem "
+ "to the canon_pp maintainer\n", tmp);
+ cs->cal_valid = SANE_FALSE;
+ } else {
+ cs->cal_valid = SANE_TRUE;
+ DBG(10, "sane_open: loadweights successful, uploading gamma"
+ " profile...\n");
+ tmp = sanei_canon_pp_adjust_gamma(&(cs->params));
+ if (tmp != 0)
+ DBG(1, "sane_open: WARNING: adjust_gamma returned "
+ "%d!\n", tmp);
+
+ DBG(10, "sane_open: after adjust_gamma Status = %i\n",
+ sanei_canon_pp_check_status(cs->params.port));
+ }
+
+
+ /* Configure ranges etc */
+
+ /* Resolution - determined by magic number */
+
+ if (cs->params.scanheadwidth == 2552)
+ cs->opt[OPT_RESOLUTION].constraint.word_list = res300;
+ else
+ cs->opt[OPT_RESOLUTION].constraint.word_list = res600;
+
+
+ /* TL-X */
+ if(!(tmp_range = malloc(sizeof(*tmp_range))))
+ return SANE_STATUS_NO_MEM;
+ (*tmp_range).min = 0;
+ (*tmp_range).max = 215;
+ cs->opt[OPT_TL_X].constraint.range = tmp_range;
+
+ /* TL-Y */
+ if(!(tmp_range = malloc(sizeof(*tmp_range))))
+ return SANE_STATUS_NO_MEM;
+ (*tmp_range).min = 0;
+ (*tmp_range).max = 296;
+ cs->opt[OPT_TL_Y].constraint.range = tmp_range;
+
+ /* BR-X */
+ if(!(tmp_range = malloc(sizeof(*tmp_range))))
+ return SANE_STATUS_NO_MEM;
+ (*tmp_range).min = 3;
+ (*tmp_range).max = 216;
+ cs->opt[OPT_BR_X].constraint.range = tmp_range;
+
+ /* BR-Y */
+ if(!(tmp_range = malloc(sizeof(*tmp_range))))
+ return SANE_STATUS_NO_MEM;
+ (*tmp_range).min = 1;
+ (*tmp_range).max = 297;
+ cs->opt[OPT_BR_Y].constraint.range = tmp_range;
+
+
+ cs->opened = SANE_TRUE;
+ cs->setup = SANE_TRUE;
+
+ *h = (SANE_Handle)cs;
+
+ DBG(2, "<< sane_open\n");
+
+ return SANE_STATUS_GOOD;
+}
+
+/*************************************************************************
+ *
+ * sane_get_option_descriptor()
+ *
+ * Return the structure for option number opt.
+ *
+ *************************************************************************/
+ const SANE_Option_Descriptor *
+sane_get_option_descriptor (SANE_Handle h, SANE_Int opt)
+{
+ CANONP_Scanner *cs = ((CANONP_Scanner *)h);
+ /*DBG(2, ">> sane_get_option_descriptor (h=%p, opt=%d)\n", h, opt);*/
+
+ if (h == NULL) {
+ DBG(10,"sane_get_option_descriptor: WARNING: h==NULL!\n");
+ return NULL;
+ }
+
+ if ((unsigned)opt >= NUM_OPTIONS) {
+ DBG(10,"sane_get_option_descriptor: Note: opt >= "
+ "NUM_OPTIONS!\n");
+ return NULL;
+ }
+
+ if (cs->opened == SANE_FALSE)
+ {
+ DBG(1,"sane_get_option_descriptor: That scanner (%p) ain't "
+ "open yet\n", h);
+ return NULL;
+ }
+
+ /*DBG(2, "<< sane_get_option_descriptor\n");*/
+
+ return (cs->opt + opt);
+}
+
+
+/*************************************************************************
+ *
+ * sane_control_option()
+ *
+ * Set a value for one of the options provided.
+ *
+ *************************************************************************/
+SANE_Status
+sane_control_option (SANE_Handle h, SANE_Int opt, SANE_Action act,
+ void *val, SANE_Word *info)
+{
+ CANONP_Scanner *cs = ((CANONP_Scanner *)h);
+ int i = 0, tmp, maxresi;
+
+ DBG(2, ">> sane_control_option (h=%p, opt=%d, act=%d)\n",
+ h,opt,act);
+ /* Do some sanity checks on the parameters
+ * note that val can be null for buttons */
+ if ((h == NULL) || ((val == NULL) && (opt != OPT_CAL)))
+ /* || (info == NULL)) - Don't check this any more..
+ * frontends seem to like passing a null */
+ {
+ DBG(1,"sane_control_option: Frontend passed me a null! "
+ "(h=%p,val=%p,info=%p)\n",(void*)h,
+ val,(void*)info);
+ return SANE_STATUS_INVAL;
+ }
+
+ if (((unsigned)opt) >= NUM_OPTIONS)
+ {
+ DBG(1,"sane_control_option: I don't do option %d.\n", opt);
+ return SANE_STATUS_INVAL;
+ }
+
+ if (cs->opened == SANE_FALSE)
+ {
+ DBG(1,"sane_control_option: That scanner (%p) ain't "
+ "open yet\n", h);
+ return SANE_STATUS_INVAL;
+ }
+
+ if (cs->scanning == SANE_TRUE)
+ {
+ DBG(1,"sane_control_option: That scanner (%p) is scanning!\n",
+ h);
+ return SANE_STATUS_DEVICE_BUSY;
+ }
+
+ switch(act)
+ {
+ case SANE_ACTION_GET_VALUE:
+ switch (opt)
+ {
+ case OPT_COLOUR_MODE:
+ strcpy((char *)val,
+ cmodes[cs->vals[opt]]);
+ break;
+ case OPT_DEPTH:
+ strcpy((char *)val,
+ depths[cs->vals[opt]]);
+ break;
+ case OPT_RESOLUTION:
+ *((int *)val) = res600[cs->vals[opt]];
+ break;
+ default:
+ *((int *)val) = cs->vals[opt];
+ break;
+ }
+ break;
+ case SANE_ACTION_SET_VALUE:
+ /* val has been checked for NULL if opt != OPT_CAL */
+ if (opt != OPT_CAL) i = *((int *)val);
+ if (info != NULL) *info = 0;
+ switch (opt) {
+ case OPT_NUM_OPTIONS:
+ /* you can't set that! */
+ return SANE_STATUS_INVAL;
+ case OPT_RESOLUTION:
+ i = cs->vals[opt];
+ cs->vals[opt] = 1;
+ maxresi = cs->opt[OPT_RESOLUTION].
+ constraint.word_list[0];
+
+ while ((cs->vals[opt] <= maxresi) &&
+ (res600[cs->vals[opt]]
+ < *((int *)val)))
+ {
+ cs->vals[opt] += 1;
+ }
+
+ if (res600[cs->vals[opt]] !=
+ *((int *)val))
+ {
+ if (info != NULL) *info |=
+ SANE_INFO_INEXACT;
+ }
+ break;
+ case OPT_COLOUR_MODE:
+ cs->vals[opt] = 0;
+ while ((cmodes[cs->vals[opt]] != NULL)
+ && strcmp(cmodes[cs->vals[opt]],
+ (char *)val))
+ {
+ cs->vals[opt] += 1;
+ }
+ if (info != NULL) *info |=
+ SANE_INFO_RELOAD_PARAMS;
+ break;
+ case OPT_DEPTH:
+ cs->vals[opt] = 0;
+ while ((depths[cs->vals[opt]] != NULL)
+ && strcmp(depths[cs->vals[opt]],
+ (char *)val))
+ {
+ cs->vals[opt] += 1;
+ }
+ if (info != NULL) *info |=
+ SANE_INFO_RELOAD_PARAMS;
+ break;
+ case OPT_TL_X:
+ case OPT_BR_X:
+ case OPT_TL_Y:
+ case OPT_BR_Y:
+ if ((i<cs->opt[opt].constraint.range->min) || (i>cs->opt[opt].constraint.range->max))
+ return SANE_STATUS_INVAL;
+ cs->vals[opt] = i;
+ break;
+ case OPT_CAL:
+ /* Call the calibration code */
+ if ((cs->weights_file==NULL) ||
+ cs->cal_readonly
+ )
+ DBG(2, ">> calibrate(x, "
+ "NULL)\n");
+ else
+ DBG(2, ">> calibrate(x,"
+ "%s)\n",
+ cs->weights_file);
+
+ if (cs->cal_readonly) tmp =
+ sanei_canon_pp_calibrate(
+ &(cs->params),
+ NULL);
+ else tmp = sanei_canon_pp_calibrate(
+ &(cs->params),
+ cs->weights_file);
+
+ DBG(2, "<< %d calibrate\n",
+ tmp);
+ if (tmp != 0) {
+ DBG(1, "sane_control_option: "
+ "WARNING: "
+ "calibrate "
+ "returned %d!",
+ tmp);
+ cs->cal_valid =
+ SANE_FALSE;
+ return SANE_STATUS_IO_ERROR;
+ } else {
+ cs->cal_valid =
+ SANE_TRUE;
+ }
+
+ break;
+ /*case OPT_PREVIEW:
+ if (i) cs->vals[opt] = 1;
+ else cs->vals[opt] = 0;
+ break;*/
+ default:
+ /* Should never happen */
+ return SANE_STATUS_INVAL;
+ }
+ break;
+ case SANE_ACTION_SET_AUTO:
+ DBG(2, "sane_control_option: attempt at "
+ "automatic control! (unsupported)\n");
+ /* Auto? are they mad? I'm not that smart! */
+ /* fall through. */
+ default:
+ return SANE_STATUS_INVAL;
+ }
+
+
+ DBG(2, "<< sane_control_option\n");
+ return SANE_STATUS_GOOD;
+}
+
+
+/*************************************************************************
+ *
+ * sane_get_parameters()
+ *
+ * Get information about the next packet. If a scan hasn't started, results
+ * only have to be best guesses.
+ *
+ *************************************************************************/
+ SANE_Status
+sane_get_parameters (SANE_Handle h, SANE_Parameters *params)
+{
+ int res, max_width, max_height, max_res;
+ CANONP_Scanner *cs = ((CANONP_Scanner *)h);
+ DBG(2, ">> sane_get_parameters (h=%p, params=%p)\n", (void*)h,
+ (void*)params);
+
+ if (h == NULL) return SANE_STATUS_INVAL;
+
+ if (cs->opened == SANE_FALSE)
+ {
+ DBG(1,"sane_get_parameters: That scanner (%p) ain't "
+ "open yet\n", h);
+ return SANE_STATUS_INVAL;
+ }
+
+ /* We use 600 res list here because the 300 res list is just a shorter
+ * version, so this will always work. */
+ res = res600[cs->vals[OPT_RESOLUTION]];
+
+ /*
+ * These don't change whether we're scanning or not
+ * NOTE: Assumes options don't change after scanning commences, which
+ * is part of the standard
+ */
+
+ /* Copy the options stored in the vals into the scaninfo */
+ params->pixels_per_line =
+ ((cs->vals[OPT_BR_X] - cs->vals[OPT_TL_X]) * res) / MM_PER_IN;
+ params->lines = ((cs->vals[OPT_BR_Y] - cs->vals[OPT_TL_Y]) * res)
+ / MM_PER_IN;
+
+ /* FIXME: Magic numbers ahead! */
+
+ max_res = cs->params.scanheadwidth == 2552 ? 300 : 600;
+
+ /* x values have to be divisible by 4 (round down) */
+ params->pixels_per_line -= (params->pixels_per_line%4);
+
+ /* Can't scan less than 64 */
+ if (params->pixels_per_line < 64) params->pixels_per_line = 64;
+
+ max_width = cs->params.scanheadwidth / (max_res / res);
+
+ max_height = (cs->params.scanheadwidth == 2552 ? 3508 : 7016) /
+ (max_res / res);
+
+ if(params->pixels_per_line > max_width)
+ params->pixels_per_line = max_width;
+ if(params->lines > max_height) params->lines = max_height;
+
+
+ params->depth = cs->vals[OPT_DEPTH] ? 16 : 8;
+
+ switch (cs->vals[OPT_COLOUR_MODE])
+ {
+ case 0:
+ params->format = SANE_FRAME_GRAY;
+ break;
+ case 1:
+ params->format = SANE_FRAME_RGB;
+ break;
+ default:
+ /* shouldn't happen */
+ break;
+ }
+
+
+ if (!(params->pixels_per_line)) {
+ params->last_frame = SANE_TRUE;
+ params->lines = 0;
+ }
+
+ /* Always the "last frame" */
+ params->last_frame = SANE_TRUE;
+
+ params->bytes_per_line = params->pixels_per_line * (params->depth/8) *
+ (cs->vals[OPT_COLOUR_MODE] ? 3 : 1);
+
+ DBG(10, "get_params: bytes_per_line=%d, pixels_per_line=%d, lines=%d\n"
+ "max_res=%d, res=%d, max_height=%d, br_y=%d, tl_y=%d, "
+ "mm_per_in=%f\n",
+ params->bytes_per_line, params->pixels_per_line, params->lines,
+ max_res, res, max_height, cs->vals[OPT_BR_Y],
+ cs->vals[OPT_TL_Y], MM_PER_IN);
+
+ DBG(2, "<< sane_get_parameters\n");
+ return SANE_STATUS_GOOD;
+}
+
+
+/*************************************************************************
+ *
+ * sane_start()
+ *
+ * Starts scanning an image.
+ *
+ *************************************************************************/
+ SANE_Status
+sane_start (SANE_Handle h)
+{
+ unsigned int i, res, max_width, max_height, max_res, tmp;
+ CANONP_Scanner *cs = ((CANONP_Scanner *)h);
+ DBG(2, ">> sane_start (h=%p)\n", h);
+
+ if (h == NULL) return SANE_STATUS_INVAL;
+
+ if (cs->scanning) return SANE_STATUS_DEVICE_BUSY;
+ if (cs->opened == SANE_FALSE)
+ {
+ DBG(1,"sane_start: That scanner (%p) ain't "
+ "open yet\n", h);
+ return SANE_STATUS_INVAL;
+ }
+
+
+ /* We use 600 res list here because the 300 res list is just a shorter
+ * version, so this will always work. */
+ res = res600[cs->vals[OPT_RESOLUTION]];
+
+ /* Copy the options stored in the vals into the scaninfo */
+ cs->scan.width = ((cs->vals[OPT_BR_X] - cs->vals[OPT_TL_X]) * res)
+ / MM_PER_IN;
+ cs->scan.height = ((cs->vals[OPT_BR_Y] - cs->vals[OPT_TL_Y]) * res)
+ / MM_PER_IN;
+
+ cs->scan.xoffset = (cs->vals[OPT_TL_X] * res) / MM_PER_IN;
+ cs->scan.yoffset = (cs->vals[OPT_TL_Y] * res) / MM_PER_IN;
+
+ /*
+ * These values have to pass the requirements of not exceeding
+ * dimensions (simple clipping) and both width values have to be some
+ * integer multiple of 4
+ */
+
+ /* FIXME: Magic numbers ahead! */
+
+ max_res = cs->params.scanheadwidth == 2552 ? 300 : 600;
+
+ /* x values have to be divisible by 4 (round down) */
+ cs->scan.width -= (cs->scan.width%4);
+ cs->scan.xoffset -= (cs->scan.xoffset%4);
+
+ /* Can't scan less than 64 */
+ if (cs->scan.width < 64) cs->scan.width = 64;
+
+ max_width = cs->params.scanheadwidth / (max_res / res);
+
+ max_height = (cs->params.scanheadwidth == 2552 ? 3508 : 7016) /
+ (max_res / res);
+
+ if (cs->scan.width > max_width) cs->scan.width = max_width;
+ if (cs->scan.width + cs->scan.xoffset > max_width) cs->scan.xoffset =
+ max_width - cs->scan.width;
+ if (cs->scan.height > max_height) cs->scan.height = max_height;
+
+ /* We pass a value to init_scan which is the power of 2 that 75
+ * is multiplied by for the resolution. ie:
+ * 75 -> 0
+ * 150 -> 1
+ * 300 -> 2
+ * 600 -> 4
+ *
+ * This rather strange parameter is a result of the way the scanner
+ * takes its resolution argument
+ */
+
+ i = 0;
+ while (res > 75)
+ {
+ i++;
+ res = res >> 1;
+ }
+
+ /* FIXME? xres == yres for now. */
+ cs->scan.xresolution = i;
+ cs->scan.yresolution = i;
+
+ if (((cs->vals[OPT_BR_Y] - cs->vals[OPT_TL_Y]) <= 0) ||
+ ((cs->vals[OPT_BR_X] - cs->vals[OPT_TL_X]) <= 0))
+ {
+ DBG(1,"sane_start: height = %d, Width = %d. "
+ "Can't scan void range!",
+ cs->scan.height, cs->scan.width);
+ return SANE_STATUS_INVAL;
+ }
+
+ cs->scan.mode = cs->vals[OPT_COLOUR_MODE];
+
+ DBG(10, ">> init_scan()\n");
+ tmp = sanei_canon_pp_init_scan(&(cs->params), &(cs->scan));
+ DBG(10, "<< %d init_scan\n", tmp);
+
+ if (tmp != 0) {
+ DBG(1,"sane_start: WARNING: init_scan returned %d!", tmp);
+ return SANE_STATUS_IO_ERROR;
+ }
+ cs->scanning = SANE_TRUE;
+ cs->cancelled = SANE_FALSE;
+ cs->sent_eof = SANE_FALSE;
+ cs->lines_scanned = 0;
+ cs->bytes_sent = 0;
+
+ DBG(2, "<< sane_start\n");
+
+ return SANE_STATUS_GOOD;
+}
+
+
+/*************************************************************************
+ *
+ * sane_read()
+ *
+ * Reads some information from the buffer.
+ *
+ *************************************************************************/
+ SANE_Status
+sane_read (SANE_Handle h, SANE_Byte *buf, SANE_Int maxlen, SANE_Int *lenp)
+{
+ CANONP_Scanner *cs = ((CANONP_Scanner *)h);
+ image_segment *is;
+ unsigned int lines, bytes, bpl;
+ unsigned int i;
+ short *shortptr;
+ SANE_Byte *charptr;
+ int tmp;
+
+ static SANE_Byte *lbuf;
+ static unsigned int bytesleft;
+
+ DBG(2, ">> sane_read (h=%p, buf=%p, maxlen=%d)\n", h,
+ (const void *)buf, maxlen);
+
+ /* default to returning 0 - for errors */
+ *lenp = 0;
+
+ if ((h == NULL) || (buf == NULL) || (lenp == NULL))
+ {
+ DBG(1, "sane_read: This frontend's passing me dodgy gear! "
+ "(h=%p, buf=%p, lenp=%p)\n",
+ (void*)h, (void*)buf, (void*)lenp);
+ return SANE_STATUS_INVAL;
+ }
+
+ /* Now we have to see if we have some leftover from last time */
+
+ if (read_leftover != NULL)
+ {
+ /* feed some more data in until we've run out - don't care
+ * whether or not we _think_ the scanner is scanning now,
+ * because we may still have data left over to send */
+ DBG(200, "sane_read: didn't send it all last time\n");
+
+ /* Now feed it some data from lbuf */
+ if (bytesleft <= (unsigned int)maxlen)
+ {
+ /* enough buffer to send the lot */
+ memcpy(buf, read_leftover, bytesleft);
+ free(lbuf);
+ *lenp = bytesleft;
+ lbuf = NULL;
+ read_leftover = NULL;
+ bytesleft = 0;
+ cs->bytes_sent += bytesleft;
+ return SANE_STATUS_GOOD;
+
+ } else {
+ /* only enough to send maxlen */
+ memcpy(buf, read_leftover, maxlen);
+ read_leftover += maxlen;
+ bytesleft -= maxlen;
+ *lenp = maxlen;
+ cs->bytes_sent += maxlen;
+ DBG(100, "sane_read: sent %d bytes, still have %d to "
+ "go\n", maxlen, bytesleft);
+ return SANE_STATUS_GOOD;
+ }
+
+ }
+
+
+ /* Has the last scan ended (other than by cancelling)? */
+ if (((unsigned)cs->scan.height <= (unsigned)cs->lines_scanned)
+ || (cs->sent_eof) || !(cs->scanning))
+ {
+ cs->sent_eof = SANE_TRUE;
+ cs->scanning = SANE_FALSE;
+ cs->cancelled = SANE_FALSE;
+ cs->lines_scanned = 0;
+ cs->bytes_sent = 0;
+ read_leftover = NULL;
+ return SANE_STATUS_EOF;
+ }
+
+ /* At this point we have to read more data from the scanner - or the
+ * scan has been cancelled, which means we have to call read_segment
+ * to leave the scanner consistant */
+
+ /* Decide how many lines we can fit into this buffer */
+ if (cs->vals[OPT_DEPTH] == 0)
+ bpl = cs->scan.width * (cs->vals[OPT_COLOUR_MODE] ? 3 : 1);
+ else
+ bpl = cs->scan.width * (cs->vals[OPT_COLOUR_MODE] ? 6 : 2);
+
+ /* New way: scan a whole scanner buffer full, and return as much as
+ * the frontend wants. It's faster and more reliable since the
+ * scanners crack the shits if we ask for too many small packets */
+ lines = (BUF_MAX * 4 / 5) / bpl;
+
+ if (lines > (cs->scan.height - cs->lines_scanned))
+ lines = cs->scan.height - cs->lines_scanned;
+
+ if (!lines)
+ {
+ /* can't fit a whole line into the buffer
+ * (should never happen!) */
+ lines = 1;
+ }
+
+ bytes = lines * bpl;
+
+ /* Allocate a local buffer to hold the data while we play */
+ if ((lbuf = malloc(bytes)) == NULL)
+ {
+ DBG(10, "sane_read: Not enough memory to hold a "
+ "local buffer. You're doomed\n");
+ return SANE_STATUS_NO_MEM;
+ }
+
+
+ /* This call required a lot of debugging information.. */
+ DBG(10, "sane_read: Here's what we're sending read_segment:\n");
+ DBG(10, "scanner setup: shw=%d xres=%d yres=%d %d %d id=%s\n",
+ cs->params.scanheadwidth,
+ cs->params.natural_xresolution,
+ cs->params.natural_yresolution,
+ cs->params.max_xresolution,
+ cs->params.max_yresolution,
+ (cs->params.id_string)+8);
+ DBG(10, "scan_params->: width=%d, height=%d, xoffset=%d, "
+ "yoffset=%d\n\txresolution=%d, yresolution=%d, "
+ "mode=%d, (lines=%d)\n",
+ cs->scan.width, cs->scan.height,
+ cs->scan.xoffset, cs->scan.yoffset,
+ cs->scan.xresolution, cs->scan.yresolution,
+ cs->scan.mode, lines);
+
+ DBG(2, ">> read_segment(x, x, x, %d, %d, %d)\n",
+ lines, cs->cal_valid,
+ cs->scan.height - cs->lines_scanned);
+ tmp = sanei_canon_pp_read_segment(&is, &(cs->params), &(cs->scan),
+ lines, cs->cal_valid,
+ cs->scan.height - cs->lines_scanned);
+ DBG(2, "<< %d read_segment\n", tmp);
+
+ if (tmp != 0) {
+ if (cs->cancelled)
+ {
+ DBG(10, "sane_read: cancelling.\n");
+ cs->sent_eof = SANE_TRUE;
+ cs->scanning = SANE_FALSE;
+ read_leftover = NULL;
+ sanei_canon_pp_abort_scan(&(cs->params));
+ return SANE_STATUS_CANCELLED;
+ }
+ DBG(1, "sane_read: WARNING: read_segment returned %d!\n", tmp);
+ return SANE_STATUS_IO_ERROR;
+ }
+
+ DBG(10, "sane_read: bpl=%d, lines=%d, bytes=%d\n", bpl, lines, bytes);
+
+ cs->lines_scanned += lines;
+
+ /* translate data out of buffer */
+ if (cs->vals[OPT_DEPTH] == 0)
+ {
+ /* 8bpp */
+ for(i = 0; i < bytes; i++)
+ {
+ charptr = lbuf + i;
+ if (cs->vals[OPT_COLOUR_MODE])
+ {
+ if (i % 3 == 0) charptr += 2;
+ if (i % 3 == 2) charptr -= 2;
+ }
+ *charptr = *((char *)(is->image_data) + (i*2));
+ }
+ }
+ else
+ {
+ /* 16bpp */
+ for(i = 0; i < (bytes/2); i++)
+ {
+ shortptr = ((short *)lbuf + i);
+ if (cs->vals[OPT_COLOUR_MODE])
+ {
+ if (i % 3 == 0) shortptr += 2;
+ if (i % 3 == 2) shortptr -= 2;
+ }
+ *shortptr = MAKE_SHORT(
+ *((char *)(is->image_data) + (i*2)),
+ *((char *)(is->image_data) + (i*2)+1)
+ );
+ }
+ }
+
+ /* Free data structures allocated in read_segment */
+ free(is->image_data);
+ free(is);
+
+ /* Now feed it some data from lbuf */
+ if (bytes <= (unsigned int)maxlen)
+ {
+ /* enough buffer to send the lot */
+ memcpy(buf, lbuf, bytes);
+ *lenp = bytes;
+ free(lbuf);
+ lbuf = NULL;
+ read_leftover = NULL;
+ bytesleft = 0;
+ cs->bytes_sent += bytes;
+
+ } else {
+ /* only enough to send maxlen */
+ memcpy(buf, lbuf, maxlen);
+ *lenp = maxlen;
+ read_leftover = lbuf + maxlen;
+ bytesleft = bytes - maxlen;
+ cs->bytes_sent += maxlen;
+ DBG(100, "sane_read: sent %d bytes, still have %d to go\n",
+ maxlen, bytesleft);
+ }
+
+ if ((unsigned)cs->lines_scanned >= cs->scan.height)
+ {
+ /* The scan is over! Don't need to call anything in the
+ * hardware, it will sort itself out */
+ DBG(10, "sane_read: Scan is finished.\n");
+ cs->scanning = SANE_FALSE;
+ cs->lines_scanned = 0;
+ cs->bytes_sent = 0;
+ }
+
+ DBG(2, "<< sane_read\n");
+ return SANE_STATUS_GOOD;
+}
+
+
+/*************************************************************************
+ *
+ * sane_cancel()
+ *
+ * Cancels a scan in progress
+ *
+ *************************************************************************/
+ void
+sane_cancel (SANE_Handle h)
+{
+ /* Note: assume handle is valid apart from NULLs */
+ CANONP_Scanner *cs = ((CANONP_Scanner *)h);
+
+ DBG(2, ">> sane_cancel (h=%p)\n", h);
+ if (h == NULL) return;
+
+ read_leftover = NULL;
+
+ if (!(cs->scanning))
+ {
+ DBG(2, "<< sane_cancel (not scanning)\n");
+ return;
+ }
+
+ cs->cancelled = SANE_TRUE;
+ cs->params.abort_now = 1;
+
+ DBG(2, "<< sane_cancel\n");
+}
+
+
+/*************************************************************************
+ *
+ * sane_close()
+ *
+ * Closes a scanner handle. Scanner is assumed to be free after this.
+ *
+ *************************************************************************/
+ void
+sane_close (SANE_Handle h)
+{
+ /* Note: assume handle is valid apart from NULLs */
+ CANONP_Scanner *cs = ((CANONP_Scanner *)h);
+ DBG(2, ">> sane_close (h=%p)\n", h);
+ if (h == NULL) return;
+
+ if (cs->opened == SANE_FALSE)
+ {
+ DBG(1,"sane_close: That scanner (%p) ain't "
+ "open yet\n", h);
+ return;
+ }
+
+ /* Put scanner back in transparent mode */
+ sanei_canon_pp_close_scanner(&(cs->params));
+
+ cs->opened = SANE_FALSE;
+
+ /* if it was scanning, it's not any more */
+ cs->scanning = SANE_FALSE;
+ cs->sent_eof = SANE_TRUE;
+
+ ieee1284_release(cs->params.port);
+
+ DBG(2, "<< sane_close\n");
+}
+
+
+/*************************************************************************
+ *
+ * sane_exit()
+ *
+ * Shut it down!
+ *
+ *************************************************************************/
+ void
+sane_exit (void)
+{
+ CANONP_Scanner *dev, *next;
+
+ DBG(2, ">> sane_exit\n");
+
+ for (dev = first_dev; dev != NULL; dev = next)
+ {
+ next = dev->next;
+
+ /* These were only created if the scanner has been init'd */
+
+ /* Should normally nullify pointers after freeing, but in
+ * this case we're about to free the whole structure so
+ * theres not a lot of point. */
+
+ /* Constraints (mostly) allocated when the scanner is opened */
+ if(dev->opt[OPT_TL_X].constraint.range)
+ free((void *)(dev->opt[OPT_TL_X].constraint.range));
+ if(dev->opt[OPT_TL_Y].constraint.range)
+ free((void *)(dev->opt[OPT_TL_Y].constraint.range));
+ if(dev->opt[OPT_BR_X].constraint.range)
+ free((void *)(dev->opt[OPT_BR_X].constraint.range));
+ if(dev->opt[OPT_BR_Y].constraint.range)
+ free((void *)(dev->opt[OPT_BR_Y].constraint.range));
+
+ /* Weights file now on a per-scanner basis */
+ if (dev->weights_file != NULL)
+ free(dev->weights_file);
+
+ if (dev->scanner_present)
+ {
+ if (dev->opened == SANE_TRUE)
+ {
+ /* naughty boys, should have closed first */
+ ieee1284_release(dev->params.port);
+ }
+ ieee1284_close(dev->params.port);
+ }
+
+ free (dev);
+ }
+
+ first_dev = NULL;
+ def_scanner = NULL;
+ read_leftover = NULL;
+ num_devices = 0;
+
+ /* FIXEDME: this created a segfault in DLL code. */
+ /* Bug was fixed in libieee1284 0.1.5 */
+ ieee1284_free_ports(&pl);
+
+ DBG(2, "<< sane_exit\n");
+}
+
+
+/*************************************************************************
+ *
+ * init_device()
+ *
+ * (Not part of the SANE API)
+ *
+ * Initialises a CANONP_Scanner data structure for a new device.
+ * NOTE: The device is not ready to scan until initialise() has been
+ * called in scan library!
+ *
+ *************************************************************************/
+static SANE_Status init_device(struct parport *pp)
+{
+ int i;
+ static const char *hw_vendor = "CANON";
+ static const char *hw_type = "flatbed scanner";
+ static const char *opt_names[] = {
+ SANE_NAME_NUM_OPTIONS,
+ SANE_NAME_SCAN_RESOLUTION,
+ SANE_NAME_SCAN_MODE,
+ SANE_NAME_BIT_DEPTH,
+ SANE_NAME_SCAN_TL_X,
+ SANE_NAME_SCAN_TL_Y,
+ SANE_NAME_SCAN_BR_X,
+ SANE_NAME_SCAN_BR_Y,
+ SANE_NAME_QUALITY_CAL
+#if 0
+ SANE_NAME_GAMMA_R,
+ SANE_NAME_GAMMA_G,
+ SANE_NAME_GAMMA_B
+#endif
+ };
+ static const char *opt_titles[] = {
+ SANE_TITLE_NUM_OPTIONS,
+ SANE_TITLE_SCAN_RESOLUTION,
+ SANE_TITLE_SCAN_MODE,
+ SANE_TITLE_BIT_DEPTH,
+ SANE_TITLE_SCAN_TL_X,
+ SANE_TITLE_SCAN_TL_Y,
+ SANE_TITLE_SCAN_BR_X,
+ SANE_TITLE_SCAN_BR_Y,
+ SANE_TITLE_QUALITY_CAL
+#if 0
+ SANE_TITLE_GAMMA_R,
+ SANE_TITLE_GAMMA_G,
+ SANE_TITLE_GAMMA_B
+#endif
+ };
+ static const char *opt_descs[] = {
+ SANE_DESC_NUM_OPTIONS,
+ SANE_DESC_SCAN_RESOLUTION,
+ SANE_DESC_SCAN_MODE,
+ SANE_DESC_BIT_DEPTH,
+ SANE_DESC_SCAN_TL_X,
+ SANE_DESC_SCAN_TL_Y,
+ SANE_DESC_SCAN_BR_X,
+ SANE_DESC_SCAN_BR_Y,
+ SANE_DESC_QUALITY_CAL
+#if 0
+ SANE_DESC_GAMMA_R,
+ SANE_DESC_GAMMA_G,
+ SANE_DESC_GAMMA_B
+#endif
+ };
+
+ CANONP_Scanner *cs = NULL;
+
+ DBG(2, ">> init_device\n");
+
+ cs = malloc(sizeof(*cs));
+ if (cs == NULL)
+ {
+ return SANE_STATUS_NO_MEM;
+ }
+ memset(cs, 0, sizeof(*cs));
+
+#if 0
+ if ((cs->params.port = malloc(sizeof(*(cs->params.port)))) == NULL)
+ return SANE_STATUS_NO_MEM;
+
+ memcpy(cs->params.port, pp, sizeof(*pp));
+#endif
+
+ cs->params.port = pp;
+
+ /* ensure these are null to start off with, otherwise they might be
+ * erroneously free'd. Note that we set everything to 0 above
+ * but that's not *always* the same thing */
+ cs->params.blackweight = NULL;
+ cs->params.redweight = NULL;
+ cs->params.greenweight = NULL;
+ cs->params.blueweight = NULL;
+
+ /* Set some sensible defaults */
+ cs->hw.name = cs->params.port->name;
+ cs->hw.vendor = hw_vendor;
+ cs->hw.type = hw_type;
+ cs->opened = SANE_FALSE;
+ cs->scanning = SANE_FALSE;
+ cs->cancelled = SANE_FALSE;
+ cs->sent_eof = SANE_TRUE;
+ cs->lines_scanned = 0;
+ cs->bytes_sent = 0;
+ cs->init_mode = INITMODE_AUTO;
+
+ DBG(10, "init_device: [configuring options]\n");
+
+ /* take a punt at each option, then we change it later */
+ for (i = 0; i < NUM_OPTIONS; i++)
+ {
+ cs->opt[i].name = opt_names[i];
+ cs->opt[i].title = opt_titles[i];
+ cs->opt[i].desc = opt_descs[i];
+ cs->opt[i].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
+ cs->opt[i].type = SANE_TYPE_INT;
+ cs->opt[i].size = sizeof(SANE_Int);
+ }
+
+ DBG(100, "init_device: configuring opt: num_options\n");
+ /* The number of options option */
+
+ cs->opt[OPT_NUM_OPTIONS].unit = SANE_UNIT_NONE;
+ cs->opt[OPT_NUM_OPTIONS].cap = SANE_CAP_SOFT_DETECT;
+ cs->vals[OPT_NUM_OPTIONS] = NUM_OPTIONS;
+
+ DBG(100, "init_device: configuring opt: resolution\n");
+
+ /* The resolution of scanning (X res == Y res for now)*/
+ cs->opt[OPT_RESOLUTION].unit = SANE_UNIT_DPI;
+ cs->opt[OPT_RESOLUTION].constraint_type = SANE_CONSTRAINT_WORD_LIST;
+ /* should never point at first element (wordlist size) */
+ cs->vals[OPT_RESOLUTION] = 1;
+
+ DBG(100, "init_device: configuring opt: colour mode\n");
+
+ /* The colour mode (0=grey 1=rgb) */
+ cs->opt[OPT_COLOUR_MODE].type = SANE_TYPE_STRING;
+ cs->opt[OPT_COLOUR_MODE].size = 20;
+ cs->opt[OPT_COLOUR_MODE].constraint_type = SANE_CONSTRAINT_STRING_LIST;
+ /* Set this one here because it doesn't change by scanner (yet) */
+ cs->opt[OPT_COLOUR_MODE].constraint.string_list = cmodes;
+
+ DBG(100, "init_device: configuring opt: bit depth\n");
+
+ /* The bit depth */
+ cs->opt[OPT_DEPTH].type = SANE_TYPE_STRING;
+ cs->opt[OPT_DEPTH].size = 20;
+ cs->opt[OPT_DEPTH].cap |= SANE_CAP_EMULATED;
+ cs->opt[OPT_DEPTH].constraint_type = SANE_CONSTRAINT_STRING_LIST;
+ cs->opt[OPT_DEPTH].constraint.string_list = depths;
+
+ DBG(100, "init_device: configuring opt: tl-x\n");
+
+ /* The top-left-x */
+ cs->opt[OPT_TL_X].unit = SANE_UNIT_MM;
+ cs->opt[OPT_TL_X].constraint_type = SANE_CONSTRAINT_RANGE;
+
+ DBG(100, "init_device: configuring opt: tl-y\n");
+
+ /* The top-left-y */
+ cs->opt[OPT_TL_Y].unit = SANE_UNIT_MM;
+ cs->opt[OPT_TL_Y].constraint_type = SANE_CONSTRAINT_RANGE;
+
+ DBG(100, "init_device: configuring opt: br-x\n");
+
+ /* The bottom-right-x */
+ cs->opt[OPT_BR_X].unit = SANE_UNIT_MM;
+ cs->opt[OPT_BR_X].constraint_type = SANE_CONSTRAINT_RANGE;
+ /* default scan width */
+ cs->vals[OPT_BR_X] = 100;
+
+ DBG(100, "init_device: configuring opt: br-y\n");
+
+ /* The bottom-right-y */
+ cs->opt[OPT_BR_Y].unit = SANE_UNIT_MM;
+ cs->opt[OPT_BR_Y].constraint_type = SANE_CONSTRAINT_RANGE;
+ cs->vals[OPT_BR_Y] = 100;
+
+ DBG(100, "init_device: configuring opt: calibrate\n");
+
+ /* The calibration button */
+ cs->opt[OPT_CAL].type = SANE_TYPE_BUTTON;
+ cs->opt[OPT_CAL].constraint_type = SANE_CONSTRAINT_NONE;
+ if (cs->cal_readonly)
+ cs->opt[OPT_CAL].cap |= SANE_CAP_INACTIVE;
+
+#if 0
+ /* the gamma values (once we do them) */
+ cs->opt[OPT_GAMMA_R].caps |= SANE_CAP_ADVANCED;
+ cs->opt[OPT_GAMMA_G].caps |= SANE_CAP_ADVANCED;
+ cs->opt[OPT_GAMMA_B].caps |= SANE_CAP_ADVANCED;
+#endif
+
+ /*
+ * NOTE: Ranges and lists are actually set when scanner is opened,
+ * becase that's when we find out what sort of scanner it is
+ */
+
+ DBG(100, "init_device: done opts\n");
+
+ /* add it to the head of the tree */
+ cs->next = first_dev;
+ first_dev = cs;
+
+ num_devices++;
+
+ DBG(2, "<< init_device\n");
+
+ return SANE_STATUS_GOOD;
+}
+
+
+/*************************************************************************
+ *
+ * These two are optional ones... maybe if I get really keen?
+ *
+ *************************************************************************/
+ SANE_Status
+sane_set_io_mode (SANE_Handle h, SANE_Bool non_blocking)
+{
+ DBG(2, ">> sane_set_io_mode (%p, %d) (not really supported)\n",
+ h, non_blocking);
+
+ if (non_blocking == SANE_FALSE)
+ return SANE_STATUS_GOOD;
+
+ DBG(2, "<< sane_set_io_mode\n");
+ return SANE_STATUS_UNSUPPORTED;
+}
+
+ SANE_Status
+sane_get_select_fd (SANE_Handle h, SANE_Int *fdp)
+{
+ DBG(2, ">> sane_get_select_fd (%p, %p) (not supported)\n", h,
+ (const void *)fdp);
+ DBG(2, "<< sane_get_select_fd\n");
+ return SANE_STATUS_UNSUPPORTED;
+}
+
+
+/*************************************************************************
+ *
+ * init_cal(): Try to create a calibration file
+ * has to be changed.
+ *
+ ************************************************************************/
+static int init_cal(char *file)
+{
+ char *tmp, *path;
+ int f, i;
+
+ if ((f = open(file, O_CREAT | O_WRONLY, 0600)) < 0)
+ {
+ if (errno == ENOENT)
+ {
+ /* we need to try and make ~/.sane perhaps -
+ * find the last / in the file path, and try
+ * to create it */
+ if ((tmp = strrchr(file, '/')) == NULL)
+ return -1;
+ path = strdup(file);
+ *(path + (tmp-file)) = '\0';
+ i = mkdir(path, 0777);
+ free(path);
+ if (i) return -1;
+ /* Path has been created, now try this again.. */
+ if ((f = open(file, O_CREAT | O_WRONLY, 0600)) < 0)
+ return -1;
+ }
+ else
+ {
+ /* Error is something like access denied - too
+ * hard to fix, so i give up... */
+ return -1;
+ }
+ }
+ /* should probably set defaults here.. */
+ close(f);
+ return 0;
+}
+
+/*************************************************************************
+ *
+ * fix_weights_file(): Ensures that the weights_file setting for a given
+ * scanner is valid
+ *
+ ************************************************************************/
+static SANE_Status fix_weights_file(CANONP_Scanner *cs)
+{
+ char *tmp, *myhome, buf[PATH_MAX];
+ int i;
+ struct stat *f_stat;
+
+
+ if (cs == NULL)
+ {
+ DBG(0, "fix_weights_file: FATAL: NULL passed by my code, "
+ "please report this!\n");
+ return SANE_STATUS_INVAL;
+ }
+
+ /* Assume this is false and then correct it */
+ cs->cal_readonly = SANE_FALSE;
+
+ if (cs->weights_file == NULL)
+ {
+ /* Will be of form canon_pp-calibration-parport0 or -0x378 */
+ sprintf(buf, "~/.sane/canon_pp-calibration-%s",
+ cs->params.port->name);
+ cs->weights_file = strdup(buf);
+ }
+
+ /* Get the user's home dir if they used ~ */
+ if (cs->weights_file[0] == '~')
+ {
+ if ((tmp = malloc(PATH_MAX)) == NULL)
+ return SANE_STATUS_NO_MEM;
+ if ((myhome = getenv("HOME")) == NULL)
+ {
+ DBG(0,"fix_weights_file: FATAL: ~ used, but $HOME not"
+ " set!\n");
+ free(tmp);
+ tmp = NULL;
+ return SANE_STATUS_INVAL;
+ }
+ strncpy(tmp, myhome, PATH_MAX);
+ strncpy(tmp+strlen(tmp), (cs->weights_file)+1,
+ PATH_MAX-strlen(tmp));
+
+ free(cs->weights_file);
+ cs->weights_file = tmp;
+ }
+
+ if ((f_stat = malloc(sizeof(*f_stat))) == NULL)
+ return SANE_STATUS_NO_MEM;
+
+ if(stat(cs->weights_file, f_stat))
+ {
+ /* this non-intuitive if basically is if we got some error that
+ * wasn't no-such-file, or we can't create the file.. */
+ if ((errno != ENOENT) || init_cal(cs->weights_file))
+ {
+ /* Some nasty error returned. Give up. */
+ DBG(2,"fix_weights_file: error stating cal file"
+ " (%s)\n", strerror(errno));
+ DBG(2,"fix_weights_file: Changes to cal data won't"
+ " be saved!\n");
+ free(cs->weights_file);
+ cs->weights_file = NULL;
+ }
+ }
+ else
+ {
+
+ /* No error returned.. Check read/writability */
+ i = open(cs->weights_file, O_RDWR | O_APPEND);
+ if (i <= 0)
+ {
+ DBG(10,"fix_weighs_file: Note: Changes to cal data "
+ "won't be saved!\n");
+ i = open(cs->weights_file, O_RDONLY);
+ if (i <= 0)
+ {
+ /*
+ * Open failed (do i care why?)
+ */
+ DBG(2,"fix_weights_file: error opening cal "
+ "(%s)\n", strerror(errno));
+ free(cs->weights_file);
+ cs->weights_file = NULL;
+ }
+ else
+ {
+ DBG(2,"fix_weights_file: file is read-only, "
+ "changes won't be saved\n");
+ cs->cal_readonly = SANE_TRUE;
+ close(i);
+ }
+ }
+ else
+ {
+ /* good! */
+ DBG(10,"fix_weights_file: Calibration file is good "
+ "for opening!\n");
+ close(i);
+ }
+ }
+
+ /* cleanup */
+ free(f_stat);
+
+ return SANE_STATUS_GOOD;
+}
+
+/* detect_mode
+ * PRE:
+ * cs->params.port is not open
+ * POST:
+ * cs->params.port is left opened iff SANE_STATUS_GOOD returned.
+ */
+
+SANE_Status detect_mode(CANONP_Scanner *cs)
+{
+
+ int capabilities, tmp;
+
+ /* Open then claim parallel port using libieee1284 */
+ DBG(10,"detect_mode: Opening port %s\n", (cs->params.port->name));
+
+ tmp = ieee1284_open(cs->params.port, 0, &capabilities);
+
+ if (tmp != E1284_OK)
+ {
+ switch (tmp)
+ {
+ case E1284_INVALIDPORT:
+ DBG(1, "detect_mode: Invalid port.\n");
+ break;
+ case E1284_SYS:
+ DBG(1, "detect_mode: System error: %s\n",
+ strerror(errno));
+ break;
+ case E1284_INIT:
+ DBG(1, "detect_mode: Initialisation error.\n");
+ break;
+ default:
+ DBG(1, "detect_mode: Unknown error.\n");
+ break;
+ }
+ return SANE_STATUS_IO_ERROR;
+ }
+
+ DBG(10,"detect_mode: Claiming port.\n");
+
+ if (ieee1284_claim(cs->params.port) != E1284_OK)
+ {
+ DBG(1,"detect_mode: Unable to claim port\n");
+ ieee1284_close(cs->params.port);
+ return SANE_STATUS_IO_ERROR;
+ }
+
+
+ /* Check that compatibility-mode (required) is supported */
+ if (!(capabilities & CAP1284_COMPAT))
+ {
+ DBG(0,"detect_mode: Compatibility mode (required) not "
+ "supported.\n");
+ ieee1284_release(cs->params.port);
+ ieee1284_close(cs->params.port);
+ return SANE_STATUS_IO_ERROR;
+ }
+
+ /* Check capabilities which will enchance speed */
+ if (capabilities & CAP1284_ECP)
+ DBG(2, "detect_mode: Port supports ECP-H.\n");
+ else if (capabilities & CAP1284_ECPSWE)
+ DBG(2, "detect_mode: Port supports ECP-S.\n");
+ if (capabilities & CAP1284_IRQ)
+ DBG(2, "detect_mode: Port supports interrupts.\n");
+ if (capabilities & CAP1284_DMA)
+ DBG(2, "detect_mode: Port supports DMA.\n");
+
+ /* Check whether ECP mode is possible */
+ if (capabilities & CAP1284_ECP)
+ {
+ cs->ieee1284_mode = M1284_ECP;
+ DBG(10, "detect_mode: Using ECP-H Mode\n");
+ }
+ else if (capabilities & CAP1284_ECPSWE)
+ {
+ cs->ieee1284_mode = M1284_ECPSWE;
+ DBG(10, "detect_mode: Using ECP-S Mode\n");
+ }
+ else if (capabilities & CAP1284_NIBBLE)
+ {
+ cs->ieee1284_mode = M1284_NIBBLE;
+ DBG(10, "detect_mode: Using nibble mode\n");
+ }
+ else
+ {
+ DBG(0, "detect_mode: No supported parport modes available!\n");
+ ieee1284_release(cs->params.port);
+ ieee1284_close(cs->params.port);
+ return SANE_STATUS_IO_ERROR;
+ }
+
+ /* Check to make sure ECP mode really is supported */
+ /* Have disabled the hardware ECP check because it's always supported
+ * by libieee1284 now, and it's too prone to hitting a ppdev bug
+ */
+
+ /* Disabled check entirely.. check now in initialise when we
+ * actually do a read */
+#if 0
+ if ((cs->ieee1284_mode == M1284_ECP) ||
+ (cs->ieee1284_mode == M1284_ECPSWE))
+ {
+ DBG(1, "detect_mode: attempting a 0 byte read, if we hang "
+ "here, it's a ppdev bug!\n");
+ /*
+ * 29/06/02
+ * NOTE:
+ * This causes an infinite loop in ppdev on 2.4.18.
+ * Not checking on hardware ECP mode should work-around
+ * effectively.
+ *
+ * I have sent email to twaugh about it, should be fixed in
+ * 2.4.19 and above.
+ */
+ if (ieee1284_ecp_read_data(cs->params.port, 0, NULL, 0) ==
+ E1284_NOTIMPL)
+ {
+ DBG(10, "detect_mode: Your version of libieee1284 "
+ "doesn't support ECP mode - defaulting"
+ " to nibble mode instead.\n");
+ cs->ieee1284_mode = M1284_NIBBLE;
+ }
+ }
+#endif
+
+ if (force_nibble == SANE_TRUE) {
+ DBG(10, "detect_mode: Nibble mode force in effect.\n");
+ cs->ieee1284_mode = M1284_NIBBLE;
+ }
+
+ ieee1284_release(cs->params.port);
+
+ sanei_canon_pp_set_ieee1284_mode(cs->ieee1284_mode);
+
+ return SANE_STATUS_GOOD;
+}