postscript/postio/parallel.c

	parallel.c revision ace1a5f11236a072fca1b5e0ea1416a083a9f2aa
/*
 * 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.
 */

#pragma ident   "%Z%%M% %I% %E% SMI"

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(7I) - 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);
}