Initial import of sane-backends version 1.0.24-1.2

1 files changed, 618 insertions, 0 deletions

diff --git a/backend/canon_pp-io.c b/backend/canon_pp-io.c
new file mode 100644
index 0000000..881ac24
--- /dev/null
+++ b/backend/canon_pp-io.c
@@ -0,0 +1,618 @@
+/* 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.
+
+   -----
+
+   This file is part of the canon_pp backend, supporting Canon CanoScan
+   Parallel scanners and also distributed as part of the stand-alone driver.  
+
+   canon_pp-io.c: $Revision$
+
+   Low Level Function library for Canon CanoScan Parallel Scanners by
+   Simon Krix <kinsei@users.sourceforge.net>
+   */
+
+#ifndef NOSANE
+#include "../include/sane/config.h"
+#endif
+
+#include <sys/time.h>
+#include <unistd.h>
+#include <ieee1284.h>
+#include "canon_pp-io.h"
+#include "canon_pp-dev.h"
+
+#ifdef NOSANE
+
+/* No SANE, Things that only apply to stand-alone */
+#include <stdio.h>
+#include <stdarg.h>
+
+static void DBG(int level, const char *format, ...)
+{
+	va_list args;
+	va_start(args, format);
+	if (level < 50) vfprintf(stderr, format, args);
+	va_end(args);
+}
+#else
+
+/* Definitions which only apply to SANE compiles */
+#ifndef VERSION
+#define VERSION "$Revision$"
+#endif
+
+/* Fix problem with DBG macro definition having a - in the name */
+#define DEBUG_DECLARE_ONLY
+#include "canon_pp.h"
+#include "../include/sane/sanei_debug.h"
+#include "../include/sane/sanei_config.h"
+
+#endif
+
+/* 0x00 = Nibble Mode (M1284_NIBBLE)
+   0x10 = ECP Mode (M1284_ECP)
+   The scanner driver seems not to support ECP RLE mode 
+   (which is a huge bummer because compression would be 
+   ace) nor EPP mode.
+   */
+static int ieee_mode = M1284_NIBBLE;
+
+/* For super-verbose debugging */
+/* #define DUMP_PACKETS 1 */
+
+/* Some sort of initialisation command */
+static unsigned char cmd_init[10] = { 0xec, 0x20, 0, 0, 0, 0, 0, 0, 0, 0 };
+
+/************* Local Prototypes ******************/
+
+/* Used by wake_scanner */
+static int scanner_reset(struct parport *port);
+static void scanner_chessboard_control(struct parport *port);
+static void scanner_chessboard_data(struct parport *port, int mode);
+
+/* Used by read_data */
+static int ieee_transfer(struct parport *port, int length, 
+		unsigned char *data);
+
+/* Low level functions */
+static int readstatus(struct parport *port);
+static int expect(struct parport *port, const char *step, int s, 
+		int mask, unsigned int delay);
+
+/* Port-level functions */
+static void outdata(struct parport *port, int d);
+static void outcont(struct parport *port, int d, int mask);
+static void outboth(struct parport *port, int d, int c);
+
+/************************************/
+
+/* 
+ * IEEE 1284 defines many values for m,
+ * but these scanners only support 2: nibble and ECP modes.
+ * And no data compression either (argh!)
+ * 0 = Nibble-mode reverse channel transfer
+ * 16 = ECP-mode
+ */
+void sanei_canon_pp_set_ieee1284_mode(int m)
+{
+	ieee_mode = m;
+}
+
+int sanei_canon_pp_wake_scanner(struct parport *port, int mode)
+{
+	/* The scanner tristates the printer's control lines
+	   (essentially disabling the passthrough port) and exits
+	   from Transparent Mode ready for communication. */
+	int i = 0;
+	int tmp;
+	int max_cycles = 3;
+	
+	tmp = readstatus(port);
+
+	/* Reset only works on 30/40 models */
+	if (mode != INITMODE_20P)
+	{
+		if ((tmp != READY))
+		{
+			DBG(40, "Scanner not ready (0x%x). Attempting to "
+					"reset...\n", tmp);
+			scanner_reset(port);
+			/* give it more of a chance to reset in this case */
+			max_cycles = 5;
+		}
+	} else {
+		DBG(0, "WARNING: Don't know how to reset an FBx20P, you may "
+				"have to power cycle\n");
+	}
+
+	do
+	{
+		i++;
+
+		/* Send the wakeup sequence */
+		scanner_chessboard_control(port);
+		scanner_chessboard_data(port, mode);
+
+		if (expect(port, NULL, 0x03, 0x1f, 800000) && 
+				(mode == INITMODE_AUTO))
+		{
+			/* 630 Style init failed, try 620 style */
+			scanner_chessboard_control(port);
+			scanner_chessboard_data(port, INITMODE_20P);
+		}
+
+		if (expect(port, "Scanner wakeup reply 1", 0x03, 0x1f, 50000))
+		{
+			outboth(port, 0x04, 0x0d);
+			usleep(100000);
+			outcont(port, 0x07, 0x0f);
+			usleep(100000);
+		}
+
+	} while ((i < max_cycles) && (!expect(port,"Scanner wakeup reply 2", 
+					0x03, 0x1f, 100000) == 0));
+
+	/* Block just after chessboarding
+	   Reply 1 (S3 and S4 on, S5 and S7 off) */
+	outcont(port, 0, HOSTBUSY); /* C1 off */
+	/* Reply 2 - If it ain't happening by now, it ain't gonna happen. */
+	if (expect(port, "Reply 2", 0xc, 0x1f, 800000))
+		return -1;
+	outcont(port, HOSTBUSY, HOSTBUSY); /* C1 on */
+	if (expect(port, "Reply 3", 0x0b, 0x1f, 800000))
+		return -1;
+	outboth(port, 0, NSELECTIN | NINIT | HOSTCLK); /* Clear D, C3+, C1- */
+
+	/* If we had to try the wakeup cycle more than once, we should wait 
+	 * here for 10 seconds to let the scanner pull itself together -
+	 * it can actually take longer, but I can't wait that long! */
+	if (i > 1)
+	{
+		DBG(10, "Had to reset scanner, waiting for the "
+				"head to get back.\n");
+		usleep(10000000);
+	}
+
+	return 0;
+}
+
+
+int sanei_canon_pp_write(struct parport *port, int length, unsigned char *data)
+{
+
+#ifdef DUMP_PACKETS
+	ssize_t count;
+
+	DBG(10,"Sending: ");
+	for (count = 0; count < length; count++)
+	{
+		DBG(10,"%02x ", data[count]);
+		if (count % 20 == 19)
+			DBG(10,"\n      ");
+	}	
+	if (count % 20 != 19) DBG(10,"\n");
+#endif
+
+	DBG(100, "NEW Send Command (length %i):\n", length);
+
+	switch (ieee_mode)
+	{
+		case M1284_BECP:
+		case M1284_ECPRLE:
+		case M1284_ECPSWE:
+		case M1284_ECP: 
+			ieee1284_negotiate(port, ieee_mode);
+			if (ieee1284_ecp_write_data(port, 0, (char *)data, 
+						length) != length)
+				return -1;
+			break;
+		case M1284_NIBBLE: 
+			if (ieee1284_compat_write(port, 0, (char *)data, 
+						length) != length)
+				return -1;
+			break;
+		default:
+			DBG(0, "Invalid mode in write!\n");
+	}		
+
+	DBG(100, "<< write");
+
+	return 0;
+}
+
+int sanei_canon_pp_read(struct parport *port, int length, unsigned char *data)
+{
+	int count, offset;
+
+	DBG(200, "NEW read_data (%i bytes):\n", length);
+	ieee1284_negotiate(port, ieee_mode);
+
+	/* This is special; Nibble mode needs a little 
+	   extra help from us. */
+
+	if (ieee_mode == M1284_NIBBLE)
+	{
+		/* Interrupt phase */
+		outcont(port, NSELECTIN, HOSTBUSY | NSELECTIN);
+		if (expect(port, "Read Data 1", 0, NDATAAVAIL, 6000000))
+		{
+			DBG(10,"Error 1\n");
+			ieee1284_terminate(port);	
+			return 1;
+		}
+		outcont(port, HOSTBUSY, HOSTBUSY);
+
+		if (expect(port, "Read Data 2",  NACK, NACK, 1000000))
+		{
+			DBG(1,"Error 2\n");
+			ieee1284_terminate(port);			
+			return 1;
+		}
+		if (expect(port, "Read Data 3 (Ready?)",  0, PERROR, 1000000))
+		{
+			DBG(1,"Error 3\n");
+			ieee1284_terminate(port);
+			return 1;
+		}
+
+		/* Host-Busy Data Available phase */
+
+		if ((readstatus(port) & NDATAAVAIL) == NDATAAVAIL)
+		{
+			DBG(1,"No data to read.\n");
+			ieee1284_terminate(port);
+			return 1;
+		}
+	}
+
+	offset = 0;
+
+	DBG(100, "-> ieee_transfer(%d) *\n", length);
+	count = ieee_transfer(port, length, data);
+	DBG(100, "<- (%d)\n", count);
+	/* Early-out if it was not implemented */
+	if (count == E1284_NOTIMPL)
+		return 2;
+
+	length -= count;
+	offset+= count;
+	while (length > 0)
+	{
+		/* If 0 bytes were transferred, it's a legal
+		   "No data" condition (I think). Otherwise,
+		   it may have run out of buffer.. keep reading*/
+		
+		if (count < 0) {
+			DBG(10, "Couldn't read enough data (need %d more "
+					"of %d)\n", length+count,length+offset);
+			ieee1284_terminate(port);
+			return 1;
+		}
+
+		DBG(100, "-> ieee_transfer(%d)\n", length);
+		count = ieee_transfer(port, length, data+offset);
+		DBG(100, "<- (%d)\n", count);
+		length-=count;
+		offset+= count;
+
+	}
+
+#ifdef DUMP_PACKETS
+	if (length <= 60)
+	{
+		DBG(10,"Read: ");
+		for (count = 0; count < length; count++)
+		{
+			DBG(10,"%02x ", data[count]);
+			if (count % 20 == 19)
+				DBG(10,"\n      ");
+		}	
+
+		if (count % 20 != 19) DBG(10,"\n");
+		}
+	else
+	{
+		DBG(10,"Read: %i bytes\n", length);
+	}			
+#endif
+
+	if (ieee_mode == M1284_NIBBLE)
+    ieee1284_terminate(port);
+
+	return 0;
+
+}
+
+static int ieee_transfer(struct parport *port, int length, unsigned char *data)
+{
+	int result = 0;
+
+	DBG(100, "IEEE transfer (%i bytes)\n", length);
+
+	switch (ieee_mode) 
+	{
+		case M1284_BECP:
+		case M1284_ECP:
+		case M1284_ECPRLE:
+		case M1284_ECPSWE:
+			result = ieee1284_ecp_read_data(port, 0, (char *)data, 
+					length);
+			break;
+		case M1284_NIBBLE:
+			result = ieee1284_nibble_read(port, 0, (char *)data, 
+					length);
+			break;
+		default:
+			DBG(1, "Internal error: Wrong mode for transfer.\n"
+				"Please email stauff1@users.sourceforge.net\n"
+				"or kinsei@users.sourceforge.net\n");
+	}
+
+	return result;
+}
+
+int sanei_canon_pp_check_status(struct parport *port)
+{
+	int status;
+	unsigned char data[2];
+
+	DBG(200, "* Check Status:\n");
+
+	if (sanei_canon_pp_read(port, 2, data))
+		return -1;
+
+	status = data[0] | (data[1] << 8);
+
+	switch(status)
+	{
+		case 0x0606:
+			DBG(200, "Ready - 0x0606\n");
+			return 0; 
+			break;
+		case 0x1414:
+			DBG(200, "Busy - 0x1414\n"); 
+			return 1;
+			break;
+		case 0x0805:
+			DBG(200, "Resetting - 0x0805\n"); 
+			return 3;
+			break;
+		case 0x1515:
+			DBG(1, "!! Invalid Command - 0x1515\n");
+			return 2; 
+			break;
+		case 0x0000:
+			DBG(200, "Nothing - 0x0000"); 
+			return 4;
+			break;
+
+		default:
+			DBG(1, "!! Unknown status - %04x\n", status);
+			return 100;
+	}
+}
+
+
+/* Send a raw byte to the printer port */
+static void outdata(struct parport *port, int d)
+{
+	ieee1284_write_data(port, d & 0xff);
+}
+
+/* Send the low nibble of d to the control port.
+   The mask affects which bits are changed. */
+static void outcont(struct parport *port, int d, int mask)
+{
+	static int control_port_status = 0;
+	control_port_status = (control_port_status & ~mask) | (d & mask);
+	ieee1284_write_control(port, (control_port_status & 0x0f));
+}
+
+/* Send a byte to both ports */
+static void outboth(struct parport *port, int d, int c)
+{
+	ieee1284_write_data(port, d & 0xff);
+	outcont(port, c, 0x0f);
+}	
+
+/* readstatus(): 
+   Returns the LOGIC value of the S register (ie: all input lines)
+   shifted right to to make it easier to read. Note: S5 is inverted
+   by ieee1284_read_status so we don't need to */
+static int readstatus(struct parport *port)
+{
+	return (ieee1284_read_status(port) & 0xf8) >> 3;
+}
+
+static void scanner_chessboard_control(struct parport *port)
+{
+	/* Wiggle C1 and C3 (twice) */
+	outboth(port, 0x0, 13);
+	usleep(10);
+	outcont(port, 7, 0xf);
+	usleep(10);
+	outcont(port, 13, 0xf);
+	usleep(10);
+	outcont(port, 7, 0xf);
+	usleep(10);	
+}
+
+static void scanner_chessboard_data(struct parport *port, int mode)
+{
+	int count;
+
+	/* initial weirdness here for 620P - seems to go quite fast,
+	 * just ignore it! */
+
+	for (count = 0; count < 2; count++)
+	{
+		/* Wiggle data lines (4 times) while strobing C1 */
+		/* 33 here for *30P, 55 for *20P */
+		if (mode == INITMODE_20P)
+			outdata(port, 0x55);
+		else
+			outdata(port, 0x33);
+		outcont(port, HOSTBUSY, HOSTBUSY);	
+		usleep(10);
+		outcont(port, 0, HOSTBUSY);	
+		usleep(10);
+		outcont(port, HOSTBUSY, HOSTBUSY);	
+		usleep(10);
+
+		if (mode == INITMODE_20P)
+			outdata(port, 0xaa);
+		else
+			outdata(port, 0xcc);
+		outcont(port, HOSTBUSY, HOSTBUSY);	
+		usleep(10);
+		outcont(port, 0, HOSTBUSY);	
+		usleep(10);
+		outcont(port, HOSTBUSY, HOSTBUSY);	
+		usleep(10);
+	}
+}
+
+/* Reset the scanner. At least, it works 50% of the time. */
+static int scanner_reset(struct parport *port) 
+{
+
+	/* Resetting only works for the *30Ps, sorry */
+	if (readstatus(port) == 0x0b)
+	{
+		/* Init Block 1 - composed of a 0-byte IEEE read */
+		ieee1284_negotiate(port, 0x0);
+		ieee1284_terminate(port);
+		ieee1284_negotiate(port, 0x0);
+		ieee1284_terminate(port);
+		scanner_chessboard_data(port, 1);
+		scanner_chessboard_data(port, 1);
+		scanner_chessboard_data(port, 1);
+		scanner_chessboard_data(port, 1);
+
+		scanner_chessboard_data(port, 0);
+		scanner_chessboard_data(port, 0);
+		scanner_chessboard_data(port, 0);
+		scanner_chessboard_data(port, 0);
+	}
+
+	/* Reset Block 2 =============== */
+	outboth(port, 0x04, 0x0d);
+
+	/* Specifically, we want this: 00111 on S */
+	if (expect(port, "Reset 2 response 1", 0x7, 0x1f, 500000))
+		return 1;
+
+	outcont(port, 0, HOSTCLK);
+	usleep(5);
+	outcont(port, 0x0f, 0xf); /* All lines must be 1. */
+
+	/* All lines 1 */
+	if (expect(port, "Reset 2 response 2 (READY)", 
+				0x1f, 0x1f, 500000))
+		return 1;
+
+	outcont(port, 0, HOSTBUSY);
+	usleep(100000); /* a short pause */
+	outcont(port, HOSTBUSY, HOSTBUSY | NSELECTIN);
+
+	return 0;
+}
+
+/* A timed version of expect, which will wait for delay before erroring 
+   This is the one and only one we should be using */
+static int expect(struct parport *port, const char *msg, int s, 
+		int mask, unsigned int delay)
+{
+	struct timeval tv;
+
+	tv.tv_sec = delay / 1000000;
+	tv.tv_usec = delay % 1000000;
+
+	if (ieee1284_wait_status(port, mask << 3, s << 3, &tv))
+	{
+		if (msg) DBG(10, "Timeout: %s (0x%02x in 0x%02x) - Status "
+				"= 0x%02x\n", msg, s, mask, readstatus(port));
+		return 1;
+	}
+
+	return 0;
+}
+
+int sanei_canon_pp_scanner_init(struct parport *port)
+{
+
+	int tries = 0;
+	int tmp = 0;
+
+	/* Put the scanner in nibble mode */
+	ieee1284_negotiate(port, 0x0);
+
+	/* No data to read yet - return to idle mode */
+	ieee1284_terminate(port);
+
+	/* In Windows, this is always ECP (or an attempt at it) */
+	if (sanei_canon_pp_write(port, 10, cmd_init))
+		return -1;
+	/* Note that we don't really mind what the status was as long as it 
+	 * wasn't a read error (returns -1) */
+	/* In fact, the 620P gives an error on that last command, but they
+	 * keep going anyway */
+	if (sanei_canon_pp_check_status(port) < 0)
+		return -1;
+
+	/* Try until it's ready */
+	sanei_canon_pp_write(port, 10, cmd_init);
+	while ((tries < 3) && (tmp = sanei_canon_pp_check_status(port)))
+	{
+		if (tmp < 0)
+			return -1;
+		DBG(10, "scanner_init: Giving the scanner a snooze...\n");
+		usleep(500000); 
+
+		tries++;
+
+		sanei_canon_pp_write(port, 10, cmd_init);
+	}
+
+	if (tries == 3) return 1;
+
+	return 0;
+}