mirror of
https://git.FreeBSD.org/src.git
synced 2024-12-21 11:13:30 +00:00
12365022c0
actually have a printer connected or online: - MAKEDEV: remove all signs of lpa add lpctl? devices (minor # = unit + 128) - usr.sbin/Makefile add lptcontrol - sys/i386/isa/lpt.c implement the LP_BYPASS flag: when a unit is opened with this flag set, the printer is not primed, and no check is made to see that the printer is online. This can only be used to pass ioctls. (giving us /dev/lpctl?) - lptcontrol.c use /dev/lpctl? (LP_BYPASS) -f flag removed, -u flag added - lptcontrol.8 document changes in lptcontrol rewrite using mandoc macros Submitted by: Geoff.
1059 lines
26 KiB
C
1059 lines
26 KiB
C
/*
|
|
* Copyright (c) 1990 William F. Jolitz, TeleMuse
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* 3. All advertising materials mentioning features or use of this software
|
|
* must display the following acknowledgement:
|
|
* This software is a component of "386BSD" developed by
|
|
* William F. Jolitz, TeleMuse.
|
|
* 4. Neither the name of the developer nor the name "386BSD"
|
|
* may be used to endorse or promote products derived from this software
|
|
* without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS A COMPONENT OF 386BSD DEVELOPED BY WILLIAM F. JOLITZ
|
|
* AND IS INTENDED FOR RESEARCH AND EDUCATIONAL PURPOSES ONLY. THIS
|
|
* SOFTWARE SHOULD NOT BE CONSIDERED TO BE A COMMERCIAL PRODUCT.
|
|
* THE DEVELOPER URGES THAT USERS WHO REQUIRE A COMMERCIAL PRODUCT
|
|
* NOT MAKE USE OF THIS WORK.
|
|
*
|
|
* FOR USERS WHO WISH TO UNDERSTAND THE 386BSD SYSTEM DEVELOPED
|
|
* BY WILLIAM F. JOLITZ, WE RECOMMEND THE USER STUDY WRITTEN
|
|
* REFERENCES SUCH AS THE "PORTING UNIX TO THE 386" SERIES
|
|
* (BEGINNING JANUARY 1991 "DR. DOBBS JOURNAL", USA AND BEGINNING
|
|
* JUNE 1991 "UNIX MAGAZIN", GERMANY) BY WILLIAM F. JOLITZ AND
|
|
* LYNNE GREER JOLITZ, AS WELL AS OTHER BOOKS ON UNIX AND THE
|
|
* ON-LINE 386BSD USER MANUAL BEFORE USE. A BOOK DISCUSSING THE INTERNALS
|
|
* OF 386BSD ENTITLED "386BSD FROM THE INSIDE OUT" WILL BE AVAILABLE LATE 1992.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE DEVELOPER ``AS IS'' AND
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE DEVELOPER BE LIABLE
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
* SUCH DAMAGE.
|
|
*
|
|
* from: unknown origin, 386BSD 0.1
|
|
* $Id: lpt.c,v 1.16 1994/08/23 07:52:20 paul Exp $
|
|
*/
|
|
|
|
/*
|
|
* Device Driver for AT parallel printer port
|
|
* Written by William Jolitz 12/18/90
|
|
*/
|
|
|
|
/*
|
|
* Parallel port TCP/IP interfaces added. I looked at the driver from
|
|
* MACH but this is a complete rewrite, and btw. incompatible, and it
|
|
* should perform better too. I have never run the MACH driver though.
|
|
*
|
|
* This driver sends two bytes (0x08, 0x00) in front of each packet,
|
|
* to allow us to distinguish another format later.
|
|
*
|
|
* TODO:
|
|
* Make Linux/Crynwr compatible mode, use IF_LLC0 to enable.
|
|
* Make HDLC/PPP mode, use IF_LLC1 to enable.
|
|
*
|
|
* Connect the two computers using a Laplink parallel cable to use this
|
|
* feature:
|
|
*
|
|
* +----------------------------------------+
|
|
* |A-name A-End B-End Descr. Port/Bit |
|
|
* +----------------------------------------+
|
|
* |DATA0 2 15 Data 0/0x01 |
|
|
* |-ERROR 15 2 1/0x08 |
|
|
* +----------------------------------------+
|
|
* |DATA1 3 13 Data 0/0x02 |
|
|
* |+SLCT 13 3 1/0x10 |
|
|
* +----------------------------------------+
|
|
* |DATA2 4 12 Data 0/0x04 |
|
|
* |+PE 12 4 1/0x20 |
|
|
* +----------------------------------------+
|
|
* |DATA3 5 10 Strobe 0/0x08 |
|
|
* |-ACK 10 5 1/0x40 |
|
|
* +----------------------------------------+
|
|
* |DATA4 6 11 Data 0/0x10 |
|
|
* |BUSY 11 6 1/~0x80 |
|
|
* +----------------------------------------+
|
|
* |GND 18-25 18-25 GND - |
|
|
* +----------------------------------------+
|
|
*
|
|
* Expect transfer-rates up to 75 kbyte/sec.
|
|
*
|
|
* If GCC could correctly grok
|
|
* register int port asm("edx")
|
|
* the code would be cleaner
|
|
*
|
|
* Poul-Henning Kamp <phk@login.dkuug.dk>
|
|
*/
|
|
|
|
#include "lpt.h"
|
|
#if NLPT > 0
|
|
|
|
#include <sys/param.h>
|
|
#include <sys/systm.h>
|
|
#include <sys/proc.h>
|
|
#include <sys/user.h>
|
|
#include <sys/buf.h>
|
|
#include <sys/kernel.h>
|
|
#include <sys/ioctl.h>
|
|
#include <sys/tty.h>
|
|
#include <sys/uio.h>
|
|
#include <sys/syslog.h>
|
|
|
|
#include <i386/isa/isa.h>
|
|
#include <i386/isa/isa_device.h>
|
|
#include <i386/isa/lptreg.h>
|
|
|
|
#include <i386/include/lpt.h>
|
|
|
|
#ifdef INET
|
|
#include <sys/mbuf.h>
|
|
#include <sys/socket.h>
|
|
#include <net/if.h>
|
|
#include <net/if_types.h>
|
|
#include <net/netisr.h>
|
|
#include <net/route.h>
|
|
#include <netinet/in.h>
|
|
#include <netinet/in_systm.h>
|
|
#include <netinet/in_var.h>
|
|
#include <netinet/ip.h>
|
|
#endif /* INET */
|
|
|
|
#define LPINITRDY 4 /* wait up to 4 seconds for a ready */
|
|
#define LPTOUTTIME 4 /* wait up to 4 seconds for a ready */
|
|
#define LPPRI (PZERO+8)
|
|
#define BUFSIZE 1024
|
|
|
|
#ifdef INET
|
|
#ifndef LPMTU /* MTU for the lp# interfaces */
|
|
#define LPMTU 1500
|
|
#endif
|
|
|
|
#ifndef LPMAXSPIN1 /* DELAY factor for the lp# interfaces */
|
|
#define LPMAXSPIN1 8000 /* Spinning for remote intr to happen */
|
|
#endif
|
|
|
|
#ifndef LPMAXSPIN2 /* DELAY factor for the lp# interfaces */
|
|
#define LPMAXSPIN2 500 /* Spinning for remote handshake to happen */
|
|
#endif
|
|
|
|
#ifndef LPMAXERRS /* Max errors before !RUNNING */
|
|
#define LPMAXERRS 100
|
|
#endif
|
|
|
|
#define LPHDR 2 /* We send 0x08, 0x00 in front of packet */
|
|
#endif /* INET */
|
|
|
|
/* BIOS printer list - used by BIOS probe*/
|
|
#define BIOS_LPT_PORTS 0x408
|
|
#define BIOS_PORTS (short *)(KERNBASE+BIOS_LPT_PORTS)
|
|
#define BIOS_MAX_LPT 4
|
|
|
|
|
|
#ifndef DEBUG
|
|
#define lprintf (void)
|
|
#else
|
|
#define lprintf if (lptflag) printf
|
|
int lptflag = 1;
|
|
#endif
|
|
|
|
#define LPTUNIT(s) ((s)&0x03)
|
|
#define LPTFLAGS(s) ((s)&0xfc)
|
|
|
|
struct lpt_softc {
|
|
short sc_port;
|
|
short sc_state;
|
|
/* default case: negative prime, negative ack, handshake strobe,
|
|
prime once */
|
|
u_char sc_control;
|
|
char sc_flags;
|
|
#define LP_POS_INIT 0x04 /* if we are a postive init signal */
|
|
#define LP_POS_ACK 0x08 /* if we are a positive going ack */
|
|
#define LP_NO_PRIME 0x10 /* don't prime the printer at all */
|
|
#define LP_PRIMEOPEN 0x20 /* prime on every open */
|
|
#define LP_AUTOLF 0x40 /* tell printer to do an automatic lf */
|
|
#define LP_BYPASS 0x80 /* bypass printer ready checks */
|
|
struct buf *sc_inbuf;
|
|
short sc_xfercnt ;
|
|
char sc_primed;
|
|
char *sc_cp ;
|
|
u_char sc_irq ; /* IRQ status of port */
|
|
#define LP_HAS_IRQ 0x01 /* we have an irq available */
|
|
#define LP_USE_IRQ 0x02 /* we are using our irq */
|
|
#define LP_ENABLE_IRQ 0x04 /* enable IRQ on open */
|
|
|
|
#ifdef INET
|
|
struct ifnet sc_if;
|
|
u_char sc_ifbuf[LPMTU+LPHDR];
|
|
int sc_iferrs;
|
|
#endif /* ENDIF */
|
|
|
|
} lpt_sc[NLPT] ;
|
|
|
|
/* bits for state */
|
|
#define OPEN (1<<0) /* device is open */
|
|
#define ASLP (1<<1) /* awaiting draining of printer */
|
|
#define ERROR (1<<2) /* error was received from printer */
|
|
#define OBUSY (1<<3) /* printer is busy doing output */
|
|
#define LPTOUT (1<<4) /* timeout while not selected */
|
|
#define TOUT (1<<5) /* timeout while not selected */
|
|
#define INIT (1<<6) /* waiting to initialize for open */
|
|
#define INTERRUPTED (1<<7) /* write call was interrupted */
|
|
|
|
|
|
/* status masks to interrogate printer status */
|
|
#define RDY_MASK (LPS_SEL|LPS_OUT|LPS_NBSY|LPS_NERR) /* ready ? */
|
|
#define LP_READY (LPS_SEL|LPS_NBSY|LPS_NERR)
|
|
|
|
/* Printer Ready condition - from lpa.c */
|
|
/* Only used in polling code */
|
|
#define LPS_INVERT (LPS_NBSY | LPS_NACK | LPS_SEL | LPS_NERR)
|
|
#define LPS_MASK (LPS_NBSY | LPS_NACK | LPS_OUT | LPS_SEL | LPS_NERR)
|
|
#define NOT_READY(x) ((inb(x)^LPS_INVERT)&LPS_MASK)
|
|
|
|
#define MAX_SLEEP (hz*5) /* Timeout while waiting for device ready */
|
|
#define MAX_SPIN 20 /* Max delay for device ready in usecs */
|
|
|
|
static void lptout (struct lpt_softc * sc);
|
|
int lptprobe (struct isa_device *dvp);
|
|
int lptattach (struct isa_device *isdp);
|
|
void lptintr (int unit);
|
|
|
|
#ifdef INET
|
|
/* Tables for the lp# interface */
|
|
static unsigned char txmith[1024];
|
|
#define txmitl (txmith+256)
|
|
#define trecvh (txmith+512)
|
|
#define trecvl (txmith+768)
|
|
|
|
/* Functions for the lp# interface */
|
|
static void lpattach(struct lpt_softc *,int);
|
|
static void lpinittables();
|
|
static int lpioctl(struct ifnet *, int, caddr_t);
|
|
static int lpoutput(struct ifnet *, struct mbuf *, struct sockaddr *,
|
|
struct rtentry *);
|
|
static void lpintr(int);
|
|
#endif /* INET */
|
|
|
|
struct isa_driver lptdriver = {
|
|
lptprobe, lptattach, "lpt"
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
* Internal routine to lptprobe to do port tests of one byte value
|
|
*/
|
|
static int
|
|
lpt_port_test(short port, u_char data, u_char mask)
|
|
{
|
|
int temp, timeout;
|
|
|
|
data = data & mask;
|
|
outb(port, data);
|
|
timeout = 10000;
|
|
do {
|
|
DELAY(10);
|
|
temp = inb(port) & mask;
|
|
}
|
|
while (temp != data && --timeout);
|
|
lprintf("Port 0x%x\tout=%x\tin=%x\ttout=%d\n",
|
|
port, data, temp, timeout);
|
|
return (temp == data);
|
|
}
|
|
|
|
/*
|
|
* New lpt port probe Geoff Rehmet - Rhodes University - 14/2/94
|
|
* Based partially on Rod Grimes' printer probe
|
|
*
|
|
* Logic:
|
|
* 1) If no port address was given, use the bios detected ports
|
|
* and autodetect what ports the printers are on.
|
|
* 2) Otherwise, probe the data port at the address given,
|
|
* using the method in Rod Grimes' port probe.
|
|
* (Much code ripped off directly from Rod's probe.)
|
|
*
|
|
* Comments from Rod's probe:
|
|
* Logic:
|
|
* 1) You should be able to write to and read back the same value
|
|
* to the data port. Do an alternating zeros, alternating ones,
|
|
* walking zero, and walking one test to check for stuck bits.
|
|
*
|
|
* 2) You should be able to write to and read back the same value
|
|
* to the control port lower 5 bits, the upper 3 bits are reserved
|
|
* per the IBM PC technical reference manauls and different boards
|
|
* do different things with them. Do an alternating zeros, alternating
|
|
* ones, walking zero, and walking one test to check for stuck bits.
|
|
*
|
|
* Some printers drag the strobe line down when the are powered off
|
|
* so this bit has been masked out of the control port test.
|
|
*
|
|
* XXX Some printers may not like a fast pulse on init or strobe, I
|
|
* don't know at this point, if that becomes a problem these bits
|
|
* should be turned off in the mask byte for the control port test.
|
|
*
|
|
* We are finally left with a mask of 0x14, due to some printers
|
|
* being adamant about holding other bits high ........
|
|
*
|
|
* Before probing the control port, we write a 0 to the data port -
|
|
* If not, some printers chuck out garbage when the strobe line
|
|
* gets toggled.
|
|
*
|
|
* 3) Set the data and control ports to a value of 0
|
|
*
|
|
* This probe routine has been tested on Epson Lx-800, HP LJ3P,
|
|
* Epson FX-1170 and C.Itoh 8510RM
|
|
* printers.
|
|
* Quick exit on fail added.
|
|
*/
|
|
int
|
|
lptprobe(struct isa_device *dvp)
|
|
{
|
|
short port;
|
|
static short next_bios_lpt = 0;
|
|
int status;
|
|
u_char data;
|
|
u_char mask;
|
|
int i;
|
|
|
|
/*
|
|
* Make sure there is some way for lptopen to see that
|
|
* the port is not configured
|
|
* This 0 will remain if the port isn't attached
|
|
*/
|
|
(lpt_sc + dvp->id_unit)->sc_port = 0;
|
|
|
|
status = IO_LPTSIZE;
|
|
/* If port not specified, use bios list */
|
|
if(dvp->id_iobase < 0) { /* port? */
|
|
if((next_bios_lpt < BIOS_MAX_LPT) &&
|
|
(*(BIOS_PORTS+next_bios_lpt) != 0) ) {
|
|
dvp->id_iobase = *(BIOS_PORTS+next_bios_lpt++);
|
|
goto end_probe;
|
|
} else
|
|
return (0);
|
|
}
|
|
|
|
/* Port was explicitly specified */
|
|
/* This allows probing of ports unknown to the BIOS */
|
|
|
|
port = dvp->id_iobase + lpt_data;
|
|
mask = 0xff;
|
|
data = 0x55; /* Alternating zeros */
|
|
if (!lpt_port_test(port, data, mask))
|
|
{ status = 0 ; goto end_probe ; }
|
|
|
|
data = 0xaa; /* Alternating ones */
|
|
if (!lpt_port_test(port, data, mask))
|
|
{ status = 0 ; goto end_probe ; }
|
|
|
|
for (i = 0; i < 8; i++) { /* Walking zero */
|
|
data = ~(1 << i);
|
|
if (!lpt_port_test(port, data, mask))
|
|
{ status = 0 ; goto end_probe ; }
|
|
}
|
|
|
|
for (i = 0; i < 8; i++) { /* Walking one */
|
|
data = (1 << i);
|
|
if (!lpt_port_test(port, data, mask))
|
|
{ status = 0 ; goto end_probe ; }
|
|
}
|
|
|
|
end_probe:
|
|
/* write 0's to control and data ports */
|
|
outb(dvp->id_iobase+lpt_data, 0);
|
|
outb(dvp->id_iobase+lpt_control, 0);
|
|
|
|
return (status);
|
|
}
|
|
|
|
/* XXX Todo - try and detect if interrupt is working */
|
|
int
|
|
lptattach(struct isa_device *isdp)
|
|
{
|
|
struct lpt_softc *sc;
|
|
|
|
sc = lpt_sc + isdp->id_unit;
|
|
sc->sc_port = isdp->id_iobase;
|
|
sc->sc_primed = 0; /* not primed yet */
|
|
outb(sc->sc_port+lpt_control, LPC_NINIT);
|
|
|
|
/* check if we can use interrupt */
|
|
lprintf("oldirq %x\n", sc->sc_irq);
|
|
if(isdp->id_irq) {
|
|
sc->sc_irq = LP_HAS_IRQ | LP_USE_IRQ | LP_ENABLE_IRQ;
|
|
printf("lpt%d: Interrupt-driven port\n", isdp->id_unit);
|
|
#ifdef INET
|
|
lpattach(sc,isdp->id_unit);
|
|
#endif
|
|
} else {
|
|
sc->sc_irq = 0;
|
|
lprintf("lpt%d: Polled port\n", isdp->id_unit);
|
|
}
|
|
lprintf("irq %x\n", sc->sc_irq);
|
|
|
|
return (1);
|
|
}
|
|
|
|
/*
|
|
* lptopen -- reset the printer, then wait until it's selected and not busy.
|
|
* If LP_BYPASS flag is selected, then we do not try to select the
|
|
* printer -- this is just used for passing ioctls.
|
|
*/
|
|
|
|
int
|
|
lptopen(dev_t dev, int flag)
|
|
{
|
|
struct lpt_softc *sc;
|
|
int s;
|
|
int trys, port;
|
|
u_int unit = LPTUNIT(minor(dev));
|
|
|
|
sc = lpt_sc + unit;
|
|
if ((unit >= NLPT) || (sc->sc_port == 0))
|
|
return (ENXIO);
|
|
|
|
#ifdef INET
|
|
if (sc->sc_if.if_flags & IFF_UP)
|
|
return(EBUSY);
|
|
#endif
|
|
if (sc->sc_state) {
|
|
lprintf("lp: still open\n") ;
|
|
lprintf("still open %x\n", sc->sc_state);
|
|
return(EBUSY);
|
|
} else sc->sc_state |= INIT;
|
|
|
|
sc->sc_flags = LPTFLAGS(minor(dev));
|
|
|
|
/* Check for open with BYPASS flag set. */
|
|
if(sc->sc_flags & LP_BYPASS) {
|
|
sc->sc_state = OPEN;
|
|
return(0);
|
|
}
|
|
|
|
s = spltty();
|
|
lprintf("lp flags 0x%x\n", sc->sc_flags);
|
|
port = sc->sc_port;
|
|
|
|
/* set IRQ status according to ENABLE_IRQ flag */
|
|
if(sc->sc_irq & LP_ENABLE_IRQ)
|
|
sc->sc_irq |= LP_USE_IRQ;
|
|
else
|
|
sc->sc_irq &= ~LP_USE_IRQ;
|
|
|
|
|
|
/* init printer */
|
|
if((sc->sc_flags & LP_NO_PRIME) == 0) {
|
|
if((sc->sc_flags & LP_PRIMEOPEN) || sc->sc_primed == 0) {
|
|
outb(port+lpt_control, 0);
|
|
sc->sc_primed++;
|
|
DELAY(500);
|
|
}
|
|
}
|
|
outb(port+lpt_control, LPC_SEL|LPC_NINIT);
|
|
|
|
/* wait till ready (printer running diagnostics) */
|
|
trys = 0;
|
|
do {
|
|
/* ran out of waiting for the printer */
|
|
if (trys++ >= LPINITRDY*4) {
|
|
splx(s);
|
|
sc->sc_state = 0;
|
|
lprintf ("status %x\n", inb(port+lpt_status) );
|
|
return (EBUSY);
|
|
}
|
|
|
|
/* wait 1/4 second, give up if we get a signal */
|
|
if (tsleep ((caddr_t)sc, LPPRI|PCATCH, "lptinit",
|
|
hz/4) != EWOULDBLOCK) {
|
|
sc->sc_state = 0;
|
|
splx(s);
|
|
return (EBUSY);
|
|
}
|
|
|
|
/* is printer online and ready for output */
|
|
} while ((inb(port+lpt_status) & (LPS_SEL|LPS_OUT|LPS_NBSY|LPS_NERR)) !=
|
|
(LPS_SEL|LPS_NBSY|LPS_NERR));
|
|
|
|
sc->sc_control = LPC_SEL|LPC_NINIT;
|
|
if(sc->sc_flags&LP_AUTOLF)
|
|
sc->sc_control |= LPC_AUTOL;
|
|
/* enable interrupt if interrupt-driven */
|
|
if(sc->sc_irq & LP_USE_IRQ)
|
|
sc->sc_control |= LPC_ENA;
|
|
|
|
outb(port+lpt_control, sc->sc_control);
|
|
|
|
sc->sc_state = OPEN;
|
|
sc->sc_inbuf = geteblk(BUFSIZE);
|
|
sc->sc_xfercnt = 0;
|
|
splx(s);
|
|
|
|
/* only use timeout if using interrupt */
|
|
lprintf("irq %x\n", sc->sc_irq);
|
|
if(sc->sc_irq & LP_USE_IRQ) {
|
|
sc->sc_state |= TOUT;
|
|
timeout ((timeout_func_t)lptout, (caddr_t)sc, hz/2);
|
|
}
|
|
lprintf("opened.\n");
|
|
return(0);
|
|
}
|
|
|
|
static void
|
|
lptout (struct lpt_softc * sc)
|
|
{ int pl;
|
|
|
|
lprintf ("T %x ", inb(sc->sc_port+lpt_status));
|
|
if (sc->sc_state&OPEN)
|
|
timeout ((timeout_func_t)lptout, (caddr_t)sc, hz/2);
|
|
else sc->sc_state &= ~TOUT;
|
|
|
|
if (sc->sc_state & ERROR)
|
|
sc->sc_state &= ~ERROR;
|
|
|
|
/*
|
|
* Avoid possible hangs do to missed interrupts
|
|
*/
|
|
if (sc->sc_xfercnt) {
|
|
pl = spltty();
|
|
lptintr(sc - lpt_sc);
|
|
splx(pl);
|
|
} else {
|
|
sc->sc_state &= ~OBUSY;
|
|
wakeup((caddr_t)sc);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* lptclose -- close the device, free the local line buffer.
|
|
*
|
|
* Check for interrupted write call added.
|
|
*/
|
|
|
|
int
|
|
lptclose(dev_t dev, int flag)
|
|
{
|
|
struct lpt_softc *sc = lpt_sc + LPTUNIT(minor(dev));
|
|
int port = sc->sc_port;
|
|
|
|
if(sc->sc_flags & LP_BYPASS)
|
|
goto end_close;
|
|
|
|
sc->sc_state &= ~OPEN;
|
|
|
|
/* if the last write was interrupted, don't complete it */
|
|
if((!(sc->sc_state & INTERRUPTED)) && (sc->sc_irq & LP_USE_IRQ))
|
|
while ((inb(port+lpt_status) & (LPS_SEL|LPS_OUT|LPS_NBSY|LPS_NERR)) !=
|
|
(LPS_SEL|LPS_NBSY|LPS_NERR) || sc->sc_xfercnt)
|
|
/* wait 1/4 second, give up if we get a signal */
|
|
if (tsleep ((caddr_t)sc, LPPRI|PCATCH,
|
|
"lpclose", hz) != EWOULDBLOCK)
|
|
break;
|
|
|
|
outb(sc->sc_port+lpt_control, LPC_NINIT);
|
|
brelse(sc->sc_inbuf);
|
|
end_close:
|
|
sc->sc_state = 0;
|
|
sc->sc_xfercnt = 0;
|
|
lprintf("closed.\n");
|
|
return(0);
|
|
}
|
|
|
|
/*
|
|
* pushbytes()
|
|
* Workhorse for actually spinning and writing bytes to printer
|
|
* Derived from lpa.c
|
|
* Originally by ?
|
|
*
|
|
* This code is only used when we are polling the port
|
|
*/
|
|
static int
|
|
pushbytes(struct lpt_softc * sc)
|
|
{
|
|
int spin, err, tic;
|
|
char ch;
|
|
int port = sc->sc_port;
|
|
|
|
lprintf("p");
|
|
/* loop for every character .. */
|
|
while (sc->sc_xfercnt > 0) {
|
|
/* printer data */
|
|
ch = *(sc->sc_cp);
|
|
sc->sc_cp++;
|
|
sc->sc_xfercnt--;
|
|
|
|
/*
|
|
* Wait for printer ready.
|
|
* Loop 20 usecs testing BUSY bit, then sleep
|
|
* for exponentially increasing timeout. (vak)
|
|
*/
|
|
for (spin=0; NOT_READY(port+lpt_status) && spin<MAX_SPIN; ++spin)
|
|
DELAY(1); /* XXX delay is NOT this accurate! */
|
|
if (spin >= MAX_SPIN) {
|
|
tic = 0;
|
|
while (NOT_READY(port+lpt_status)) {
|
|
/*
|
|
* Now sleep, every cycle a
|
|
* little longer ..
|
|
*/
|
|
tic = tic + tic + 1;
|
|
/*
|
|
* But no more than 10 seconds. (vak)
|
|
*/
|
|
if (tic > MAX_SLEEP)
|
|
tic = MAX_SLEEP;
|
|
err = tsleep((caddr_t)sc, LPPRI,
|
|
"lptpoll", tic);
|
|
if (err != EWOULDBLOCK) {
|
|
return (err);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* output data */
|
|
outb(port+lpt_data, ch);
|
|
/* strobe */
|
|
outb(port+lpt_control, sc->sc_control|LPC_STB);
|
|
outb(port+lpt_control, sc->sc_control);
|
|
|
|
}
|
|
return(0);
|
|
}
|
|
|
|
/*
|
|
* lptwrite --copy a line from user space to a local buffer, then call
|
|
* putc to get the chars moved to the output queue.
|
|
*
|
|
* Flagging of interrupted write added.
|
|
*/
|
|
|
|
int
|
|
lptwrite(dev_t dev, struct uio * uio)
|
|
{
|
|
register unsigned n;
|
|
int pl, err;
|
|
struct lpt_softc *sc = lpt_sc + LPTUNIT(minor(dev));
|
|
|
|
if(sc->sc_flags & LP_BYPASS) {
|
|
/* we can't do writes in bypass mode */
|
|
return(EPERM);
|
|
}
|
|
|
|
sc->sc_state &= ~INTERRUPTED;
|
|
while (n = min(BUFSIZE, uio->uio_resid)) {
|
|
sc->sc_cp = sc->sc_inbuf->b_un.b_addr ;
|
|
uiomove(sc->sc_cp, n, uio);
|
|
sc->sc_xfercnt = n ;
|
|
while ((sc->sc_xfercnt > 0)&&(sc->sc_irq & LP_USE_IRQ)) {
|
|
lprintf("i");
|
|
/* if the printer is ready for a char, */
|
|
/* give it one */
|
|
if ((sc->sc_state & OBUSY) == 0){
|
|
lprintf("\nC %d. ", sc->sc_xfercnt);
|
|
pl = spltty();
|
|
lptintr(sc - lpt_sc);
|
|
(void) splx(pl);
|
|
}
|
|
lprintf("W ");
|
|
if (sc->sc_state & OBUSY)
|
|
if ((err = tsleep ((caddr_t)sc,
|
|
LPPRI|PCATCH, "lpwrite", 0))) {
|
|
sc->sc_state |= INTERRUPTED;
|
|
return(err);
|
|
}
|
|
}
|
|
/* check to see if we must do a polled write */
|
|
if(!(sc->sc_irq & LP_USE_IRQ) && (sc->sc_xfercnt)) {
|
|
lprintf("p");
|
|
if((err = pushbytes(sc)))
|
|
return(err);
|
|
}
|
|
}
|
|
return(0);
|
|
}
|
|
|
|
/*
|
|
* lptintr -- handle printer interrupts which occur when the printer is
|
|
* ready to accept another char.
|
|
*
|
|
* do checking for interrupted write call.
|
|
*/
|
|
|
|
void
|
|
lptintr(int unit)
|
|
{
|
|
struct lpt_softc *sc = lpt_sc + unit;
|
|
int port = sc->sc_port, sts;
|
|
|
|
#ifdef INET
|
|
if(sc->sc_if.if_flags & IFF_UP) {
|
|
lpintr(unit);
|
|
return;
|
|
}
|
|
#endif /* INET */
|
|
|
|
/* is printer online and ready for output */
|
|
if (((sts=inb(port+lpt_status)) & RDY_MASK) == LP_READY) {
|
|
sc->sc_state = (sc->sc_state | OBUSY) & ~ERROR;
|
|
|
|
if (sc->sc_xfercnt) {
|
|
/* send char */
|
|
/*lprintf("%x ", *sc->sc_cp); */
|
|
outb(port+lpt_data, *sc->sc_cp++) ;
|
|
outb(port+lpt_control, sc->sc_control|LPC_STB);
|
|
/* DELAY(X) */
|
|
outb(port+lpt_control, sc->sc_control);
|
|
|
|
/* any more data for printer */
|
|
if(--(sc->sc_xfercnt) > 0) return;
|
|
}
|
|
|
|
/*
|
|
* No more data waiting for printer.
|
|
* Wakeup is not done if write call was interrupted.
|
|
*/
|
|
sc->sc_state &= ~OBUSY;
|
|
if(!(sc->sc_state & INTERRUPTED))
|
|
wakeup((caddr_t)sc);
|
|
lprintf("w ");
|
|
return;
|
|
} else { /* check for error */
|
|
if(((sts & (LPS_NERR | LPS_OUT) ) != LPS_NERR) &&
|
|
(sc->sc_state & OPEN))
|
|
sc->sc_state |= ERROR;
|
|
}
|
|
lprintf("sts %x ", sts);
|
|
}
|
|
|
|
int
|
|
lptioctl(dev_t dev, int cmd, caddr_t data, int flag)
|
|
{
|
|
int error = 0;
|
|
struct lpt_softc *sc;
|
|
u_int unit = LPTUNIT(minor(dev));
|
|
u_char old_sc_irq; /* old printer IRQ status */
|
|
|
|
sc = lpt_sc + unit;
|
|
|
|
switch (cmd) {
|
|
case LPT_IRQ :
|
|
if(sc->sc_irq & LP_HAS_IRQ) {
|
|
/*
|
|
* NOTE:
|
|
* If the IRQ status is changed,
|
|
* this will only be visible on the
|
|
* next open.
|
|
*
|
|
* If interrupt status changes,
|
|
* this gets syslog'd.
|
|
*/
|
|
old_sc_irq = sc->sc_irq;
|
|
if(*(int*)data == 0)
|
|
sc->sc_irq &= (~LP_ENABLE_IRQ);
|
|
else
|
|
sc->sc_irq |= LP_ENABLE_IRQ;
|
|
if (old_sc_irq != sc->sc_irq )
|
|
log(LOG_NOTICE, "lpt%c switched to %s mode\n",
|
|
(char)unit+'0',
|
|
(sc->sc_irq & LP_ENABLE_IRQ)?
|
|
"interrupt-driven":"polled");
|
|
} else /* polled port */
|
|
error = EOPNOTSUPP;
|
|
break;
|
|
default:
|
|
error = ENODEV;
|
|
}
|
|
|
|
return(error);
|
|
}
|
|
|
|
#ifdef INET
|
|
|
|
static inline void
|
|
ob1(u_int port, u_char data)
|
|
{
|
|
__asm __volatile("
|
|
decl %%edx
|
|
outb %%al,%%dx
|
|
incl %%edx
|
|
" : : "a" (data), "d" (port));
|
|
}
|
|
|
|
static void
|
|
lpattach(struct lpt_softc *sc,int unit)
|
|
{
|
|
struct ifnet *ifp = &sc->sc_if;
|
|
|
|
ifp->if_name = "lp";
|
|
ifp->if_unit = unit;
|
|
ifp->if_mtu = LPMTU;
|
|
ifp->if_flags = IFF_SIMPLEX | IFF_BROADCAST;
|
|
ifp->if_ioctl = lpioctl;
|
|
ifp->if_output = lpoutput;
|
|
ifp->if_type = IFT_SLIP;
|
|
ifp->if_hdrlen = 0;
|
|
ifp->if_addrlen = 0;
|
|
ifp->if_snd.ifq_maxlen = IFQ_MAXLEN;
|
|
if_attach(ifp);
|
|
printf("lp%d: TCP/IP interface, MTU=%d.\n",unit,LPMTU);
|
|
}
|
|
/*
|
|
* We don't want to calculate these nasties in our tight loop, so we
|
|
* precalculate them when we initialize.
|
|
*/
|
|
static void
|
|
lpinittables()
|
|
{
|
|
int i;
|
|
|
|
for(i=0;i<256;i++) {
|
|
txmith[i] = ((i & 0x80) >> 3) | ((i & 0x70) >> 4) | 0x08;
|
|
txmitl[i] = ((i & 0x08) << 1) | (i & 0x07);
|
|
trecvh[i] = ((~i) & 0x80) | ((i & 0x38) << 1);
|
|
trecvl[i] = (((~i) & 0x80) >> 4) | ((i & 0x38) >> 3);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Process an ioctl request.
|
|
*/
|
|
/* ARGSUSED */
|
|
static int
|
|
lpioctl(struct ifnet *ifp, int cmd, caddr_t data)
|
|
{
|
|
struct proc *p = curproc;
|
|
struct lpt_softc *sc = lpt_sc + ifp->if_unit;
|
|
struct ifaddr *ifa = (struct ifaddr *)data;
|
|
struct ifreq *ifr = (struct ifreq *)data;
|
|
|
|
int error = 0;
|
|
|
|
switch (cmd) {
|
|
|
|
case SIOCSIFFLAGS:
|
|
if (((ifp->if_flags & IFF_UP) == 0) &&
|
|
(ifp->if_flags & IFF_RUNNING)) {
|
|
outb(sc->sc_port+2, 0x00);
|
|
ifp->if_flags &= ~IFF_RUNNING;
|
|
}
|
|
if (((ifp->if_flags & IFF_UP)) &&
|
|
((ifp->if_flags & IFF_RUNNING) == 0)) {
|
|
lpinittables();
|
|
outb(sc->sc_port+2, 0x10);
|
|
ifp->if_flags |= IFF_RUNNING;
|
|
}
|
|
break;
|
|
|
|
case SIOCAIFADDR:
|
|
case SIOCSIFADDR:
|
|
if (ifa->ifa_addr->sa_family != AF_INET)
|
|
error = EAFNOSUPPORT;
|
|
lpinittables();
|
|
outb(sc->sc_port+2, 0x10);
|
|
ifp->if_flags |= IFF_RUNNING | IFF_UP;
|
|
break;
|
|
case SIOCSIFDSTADDR:
|
|
if (ifa->ifa_addr->sa_family != AF_INET)
|
|
error = EAFNOSUPPORT;
|
|
ifp->if_flags = IFF_POINTOPOINT;
|
|
break;
|
|
|
|
case SIOCSIFMTU:
|
|
if ((error = suser(p->p_ucred, &p->p_acflag)))
|
|
return (error);
|
|
if(ifr->ifr_metric > LPMTU)
|
|
error = EINVAL;
|
|
sc->sc_if.if_mtu = ifr->ifr_metric;
|
|
break;
|
|
|
|
case SIOCGIFMTU:
|
|
ifr->ifr_metric = sc->sc_if.if_mtu;
|
|
break;
|
|
|
|
default:
|
|
lprintf("LP:ioctl%x\n",cmd);
|
|
error = EINVAL;
|
|
}
|
|
return (error);
|
|
}
|
|
|
|
static void
|
|
lpintr(int unit)
|
|
{
|
|
struct lpt_softc *sc = lpt_sc + unit;
|
|
int len,s,j;
|
|
register const int port = sc->sc_port+1;
|
|
|
|
s = splimp();
|
|
while((inb(port)&0x40)) {
|
|
{
|
|
u_long c, cl;
|
|
for(len=0;len<LPMTU+LPHDR;) {
|
|
__asm __volatile("
|
|
inb %%dx,%%al
|
|
movzbl %%al,%0
|
|
decl %%edx
|
|
movb $8,%%al
|
|
outb %%al,%%dx
|
|
incl %%edx
|
|
" : "=b" (cl) : "d" (port) : "a");
|
|
{
|
|
j = LPMAXSPIN2;
|
|
while((inb(port)&0x40))
|
|
if(!--j) goto err;
|
|
}
|
|
__asm __volatile("
|
|
inb %%dx,%%al
|
|
movzbl %%al,%0
|
|
decl %%edx
|
|
xorl %%eax,%%eax
|
|
outb %%al,%%dx
|
|
incl %%edx
|
|
" : "=b" (c) : "d" (port) : "a");
|
|
sc->sc_ifbuf[len++] = trecvh[cl] | trecvl[c];
|
|
{
|
|
j = LPMAXSPIN2;
|
|
while(!((cl=inb(port)) & 0x40)) {
|
|
if(cl != c && (((cl=inb(port))^0xb8)&0xf8) == (c&0xf8))
|
|
goto end;
|
|
if(!--j) goto err;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
end:
|
|
if(len <= LPHDR)
|
|
goto err;
|
|
|
|
sc->sc_iferrs=0;
|
|
|
|
if(IF_QFULL(&ipintrq)) {
|
|
lprintf("DROP");
|
|
IF_DROP(&ipintrq);
|
|
goto done;
|
|
}
|
|
len -= LPHDR;
|
|
sc->sc_if.if_ipackets++;
|
|
sc->sc_if.if_ibytes += len;
|
|
{
|
|
u_char *p = sc->sc_ifbuf+LPHDR;
|
|
struct mbuf *top, *m, *m2;
|
|
MGETHDR(m, M_DONTWAIT, MT_DATA);
|
|
top = m;
|
|
m->m_len=0;
|
|
m->m_pkthdr.len = len;
|
|
m->m_pkthdr.rcvif = &sc->sc_if;
|
|
while(len > 0) {
|
|
m2 = m;
|
|
MGET(m, M_DONTWAIT, MT_DATA);
|
|
if(len > MINCLSIZE) {
|
|
MCLGET(m, M_DONTWAIT);
|
|
}
|
|
m->m_len=0;
|
|
m2->m_next = m;
|
|
j = min(len,M_TRAILINGSPACE(m));
|
|
bcopy(p, mtod(m, caddr_t), j);
|
|
m->m_len=j;
|
|
len -= j;
|
|
p += j;
|
|
}
|
|
IF_ENQUEUE(&ipintrq, top);
|
|
schednetisr(NETISR_IP);
|
|
}
|
|
}
|
|
goto done;
|
|
err:
|
|
outb(sc->sc_port,0x00);
|
|
lprintf("R");
|
|
sc->sc_if.if_ierrors++;
|
|
sc->sc_iferrs++;
|
|
if(sc->sc_iferrs > LPMAXERRS) {
|
|
/* We are not able to send receive anything for now,
|
|
* so stop wasting our time
|
|
*/
|
|
printf("lp%d: Too many errors, Going off-line.\n", unit);
|
|
outb(sc->sc_port+2, 0x00);
|
|
sc->sc_if.if_flags &= ~IFF_RUNNING;
|
|
sc->sc_iferrs=0;
|
|
}
|
|
done:
|
|
splx(s);
|
|
return;
|
|
}
|
|
|
|
|
|
static int
|
|
lpoutput(struct ifnet *ifp, struct mbuf *m,
|
|
struct sockaddr *dst, struct rtentry *rt)
|
|
{
|
|
register int port = lpt_sc[ifp->if_unit].sc_port+1;
|
|
int s,i;
|
|
u_char *cp;
|
|
struct mbuf *mm=m;
|
|
|
|
s=splimp();
|
|
|
|
/* Suspend (on laptops) or receive-errors might have taken us offline */
|
|
outb(port+1, 0x10);
|
|
ifp->if_flags |= IFF_RUNNING;
|
|
|
|
if(inb(port)&0x40) {
|
|
lprintf("&");
|
|
lptintr(ifp->if_unit);
|
|
}
|
|
i = LPMAXSPIN1;
|
|
ob1(port,txmith[0x08]);
|
|
while(!(inb(port)&0x40)) if(!--i) goto end;
|
|
ob1(port,txmitl[0x08]);
|
|
while((inb(port)&0x40)) if(!--i) goto end;
|
|
|
|
i = LPMAXSPIN2;
|
|
ob1(port,txmith[0x00]);
|
|
while(!(inb(port)&0x40)) if(!--i) goto end;
|
|
ob1(port,txmitl[0x00]);
|
|
while((inb(port)&0x40)) if(!--i) goto end;
|
|
|
|
do {
|
|
cp = mtod(mm,u_char *);
|
|
for(;mm->m_len--;i=LPMAXSPIN2) {
|
|
ob1(port,txmith[*cp]);
|
|
while(!(inb(port)&0x40)) if(!--i) goto end;
|
|
ob1(port,txmitl[*cp++]);
|
|
while((inb(port)&0x40)) if(!--i) goto end;
|
|
}
|
|
} while ((mm = mm->m_next));
|
|
end:
|
|
ob1(port,txmitl[cp[-1]] ^ 0x17);
|
|
if(i) {
|
|
ifp->if_opackets++;
|
|
ifp->if_obytes += m->m_pkthdr.len;
|
|
} else {
|
|
ifp->if_oerrors++;
|
|
lprintf("X");
|
|
}
|
|
m_freem(m);
|
|
if((inb(port)&0x40)) {
|
|
lprintf("^");
|
|
lptintr(ifp->if_unit);
|
|
}
|
|
(void)splx(s);
|
|
return 0;
|
|
}
|
|
|
|
#endif /* INET */
|
|
|
|
#endif /* NLPT */
|