Initial import of sane-backends version 1.0.24-1.2

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;
+}