xref: /illumos-gate/usr/src/cmd/lp/filter/postscript/postio/parallel.c (revision bbf21555)

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

extern char *postbegin;

#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <stdarg.h>
#include <signal.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/ioccom.h>
#include <sys/ioctl.h>

#include <sys/bpp_io.h>
#include <sys/ecppsys.h>
#include <sys/prnio.h>

#define PRINTER_IO_ERROR	129

/*
 * the parameter structure for the parallel port
 */
struct ppc_params_t {
	int		flags;		/* same as above */
	int		state;		/* status of the printer interface */
	int		strobe_w;	/* strobe width, in uS */
	int		data_setup;	/* data setup time, in uS */
	int		ack_timeout;	/* ACK timeout, in secs */
	int		error_timeout;	/* PAPER OUT, etc... timeout, in secs */
	int		busy_timeout;	/* BUSY timeout, in seconds */
};



extern char *block;
extern int head, tail;
extern int readblock(int);
extern FILE *fp_log;
static void printer_info(char *fmt, ...);

/*	These are the routines avaliable to others for use 	*/
int is_a_parallel_bpp(int);
int bpp_state(int);
int parallel_comm(int, int());
int get_ecpp_status(int);
int is_a_prnio(int);
int prnio_state(int);

#define PRINTER_ERROR_PAPER_OUT		1
#define PRINTER_ERROR_OFFLINE		2
#define PRINTER_ERROR_BUSY		3
#define PRINTER_ERROR_ERROR		4
#define PRINTER_ERROR_CABLE_POWER	5
#define PRINTER_ERROR_UNKNOWN		6
#define PRINTER_ERROR_TIMEOUT		7

/****************************************************************************/

/**
 *	for BPP PARALLEL interfaces
 **/

int is_a_parallel_bpp(int fd)
{
	if (ioctl(fd, BPPIOC_TESTIO) == 0 || errno == EIO)
		return(1);
	return(0);
}


#if defined(DEBUG) && defined(NOTDEF)
char *BppState(int state)
{
	static char buf[BUFSIZ];

	memset(buf, 0, sizeof(buf));
	sprintf(buf, "State (0x%.4x) - (%s%s%s%s)\n", state,
		((state & BPP_SLCT_ERR) ?  "offline " : ""),
		((state & BPP_BUSY_ERR) ?  "busy " : ""),
		((state & BPP_PE_ERR) ?  "paper " : ""),
		((state & BPP_ERR_ERR) ?  "error " : ""));

	return(buf);
}
#endif

int bpp_state(int fd)
{
	if (ioctl(fd, BPPIOC_TESTIO)) {
		struct bpp_error_status  bpp_stat;
		int state;

		if (ioctl(fd, BPPIOC_GETERR, &bpp_stat) < 0)
			exit(PRINTER_IO_ERROR);
		state = bpp_stat.pin_status;

#if defined(DEBUG) && defined(NOTDEF)
		logit("%s", BppState(state));
#endif

		if (state == (BPP_PE_ERR | BPP_ERR_ERR | BPP_SLCT_ERR)) {
			/* paper is out */
			return(PRINTER_ERROR_PAPER_OUT);
		} else if (state & BPP_BUSY_ERR) {
			/* printer is busy */
			return(PRINTER_ERROR_BUSY);
		} else if (state & BPP_SLCT_ERR) {
			/* printer is offline */
			return(PRINTER_ERROR_OFFLINE);
		} else if (state & BPP_ERR_ERR) {
			/* printer is errored */
			return(PRINTER_ERROR_ERROR);
		} else if (state == BPP_PE_ERR) {
			/* printer is off/unplugged */
			return(PRINTER_ERROR_CABLE_POWER);
		} else if (state) {
			return(PRINTER_ERROR_UNKNOWN);
		} else
			return(0);
	}
	return(0);
}

int
get_ecpp_status(int fd)
{
	int state;
	struct ecpp_transfer_parms transfer_parms;


	if (ioctl(fd, ECPPIOC_GETPARMS, &transfer_parms) == -1) {
		return(-1);
	}

	state = transfer_parms.mode;
	/*
	 * We don't know what all printers will return in
	 * nibble mode, therefore if we support nibble mode we will
	 * force the printer to be in CENTRONICS mode.
	 */

	if (state != ECPP_CENTRONICS) {
		transfer_parms.mode = ECPP_CENTRONICS;
		if (ioctl(fd, ECPPIOC_SETPARMS, &transfer_parms) == -1) {
			return(-1);
		} else {
			state = ECPP_CENTRONICS;
		}
	}

	return(state);
}

/**
 * For prnio(4I) - generic printer interface
 **/
int is_a_prnio(int fd)
{
	uint_t	cap;

	/* check if device supports prnio */
	if (ioctl(fd, PRNIOC_GET_IFCAP, &cap) == -1) {
		return (0);
	}
	/* we will use 1284 status if available */
	if ((cap & PRN_1284_STATUS) == 0) {
		/* some devices may only support 1284 status in unidir. mode */
		if (cap & PRN_BIDI) {
			cap &= ~PRN_BIDI;
			(void) ioctl(fd, PRNIOC_SET_IFCAP, &cap);
		}
	}
	return (1);
}

int prnio_state(int fd)
{
	uint_t	status;
	uchar_t	pins;

	if ((ioctl(fd, PRNIOC_GET_STATUS, &status) == 0) &&
	    (status & PRN_READY)) {
		return(0);
	}

	if (ioctl(fd, PRNIOC_GET_1284_STATUS, &pins) != 0) {
		return(PRINTER_ERROR_UNKNOWN);
	}

	if ((pins & ~PRN_1284_BUSY) == PRN_1284_PE) {
		/* paper is out */
		return(PRINTER_ERROR_PAPER_OUT);
	} else if (pins == (PRN_1284_PE | PRN_1284_SELECT |
				PRN_1284_NOFAULT | PRN_1284_BUSY)) {
		/* printer is off/unplugged */
		return(PRINTER_ERROR_CABLE_POWER);
	} else if ((pins & PRN_1284_SELECT) == 0) {
		/* printer is offline */
		return(PRINTER_ERROR_OFFLINE);
	} else if ((pins & PRN_1284_NOFAULT) == 0) {
		/* printer is errored */
		return(PRINTER_ERROR_ERROR);
	} else if (pins & PRN_1284_PE) {
		/* paper is out */
		return(PRINTER_ERROR_PAPER_OUT);
	} else if (pins ^ (PRN_1284_SELECT | PRN_1284_NOFAULT)) {
		return(PRINTER_ERROR_UNKNOWN);
	}
	return(0);
}

/**
 *	Common routines
 **/

/*ARGSUSED0*/
static void
ByeByeParallel(int sig)
{
	/* try to shove out the EOT */
	(void) write(1, "\004", 1);
	exit(0);
}


/*ARGSUSED0*/
static void
printer_info(char *fmt, ...)
{
	char mesg[BUFSIZ];
	va_list ap;

	va_start(ap, fmt);
	vsprintf(mesg, fmt, ap);
	va_end(ap);

	fprintf(stderr,
		"%%%%[ PrinterError: %s; source: parallel ]%%%%\n",
		mesg);
	fflush(stderr);
	fsync(2);

	if (fp_log != stderr) {
		fprintf(fp_log,
		   "%%%%[ PrinterError: %s; source: parallel ]%%%%\n",
		   mesg);
		fflush(fp_log);
	}
}

static void
printer_error(int error)
{
	switch (error) {
		case -1:
			printer_info("ioctl(): %s", strerror(errno));
			break;
		case PRINTER_ERROR_PAPER_OUT:
			printer_info("out of paper");
			break;
		case PRINTER_ERROR_OFFLINE:
			printer_info("offline");
			break;
		case PRINTER_ERROR_BUSY:
			printer_info("busy");
			break;
		case PRINTER_ERROR_ERROR:
			printer_info("printer error");
			break;
		case PRINTER_ERROR_CABLE_POWER:
			printer_info("printer powered off or disconnected");
			break;
		case PRINTER_ERROR_UNKNOWN:
			printer_info("unknown error");
			break;
		case PRINTER_ERROR_TIMEOUT:
			printer_info("communications timeout");
			break;
		default:
			printer_info("get_status() failed");
	}
}


static void
wait_state(int fd, int get_state())
{
	int state;
	int was_faulted = 0;

	while (state = get_state(fd)) {
		was_faulted=1;
		printer_error(state);
		sleep(15);
	}

	if (was_faulted) {
		fprintf(stderr, "%%%%[ status: idle ]%%%%\n");
		fflush(stderr);
		fsync(2);
		if (fp_log != stderr) {
			fprintf(fp_log, "%%%%[ status: idle ]%%%%\n");
			fflush(fp_log);
		}
	}
}


int
parallel_comm(int fd, int get_state())
{
	int  actual;		/* number of bytes successfully written */
	int count = 0;

	(void) signal(SIGTERM, ByeByeParallel);
	(void) signal(SIGQUIT, ByeByeParallel);
	(void) signal(SIGHUP, ByeByeParallel);
	(void) signal(SIGINT, ByeByeParallel);
	(void) signal(SIGALRM, SIG_IGN);

	/* is the device ready? */

	/* bracket job with EOT */
	wait_state(fd, get_state);
	(void) write(fd, "\004", 1);

/* 	write(fd, postbegin, strlen(postbegin)); */

	while (readblock(fileno(stdin)) > 0) {
		wait_state(fd, get_state);
		alarm(120);
		if ((actual = write(fd, block + head, tail - head)) == -1) {
			alarm(0);
		  	if (errno == EINTR) {
				printer_error(PRINTER_ERROR_TIMEOUT);
				sleep(30);
				continue;
			} else {
				printer_info("I/O Error during write(): %s",
					strerror(errno));
				exit(2);
			}
		}
		alarm(0);
		if (actual >= 0)
			head += actual;

#if defined(DEBUG) && defined(NOTDEF)
		logit("Writing (%d) at 0x%x actual: %d, %s\n", count++, head,
			actual, (actual < 1 ? strerror(errno) : ""));
#endif
	}

	/* write the final EOT */
	wait_state(fd, get_state);
	(void) write(fd, "\004", 1);

	return (0);
}