![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to lpt.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Net/2] / Net2 / arch / i386 / isa|
Return to lpt.c CVS log | Up to [Net/2] / Net2 / arch / i386 / isa |
1.1 root 1: /*
2: * Copyright (c) 1990 William F. Jolitz, TeleMuse
3: * All rights reserved.
4: *
5: * Redistribution and use in source and binary forms, with or without
6: * modification, are permitted provided that the following conditions
7: * are met:
8: * 1. Redistributions of source code must retain the above copyright
9: * notice, this list of conditions and the following disclaimer.
10: * 2. Redistributions in binary form must reproduce the above copyright
11: * notice, this list of conditions and the following disclaimer in the
12: * documentation and/or other materials provided with the distribution.
13: * 3. All advertising materials mentioning features or use of this software
14: * must display the following acknowledgement:
15: * This software is a component of "386BSD" developed by
16: * William F. Jolitz, TeleMuse.
17: * 4. Neither the name of the developer nor the name "386BSD"
18: * may be used to endorse or promote products derived from this software
19: * without specific prior written permission.
20: *
21: * THIS SOFTWARE IS A COMPONENT OF 386BSD DEVELOPED BY WILLIAM F. JOLITZ
22: * AND IS INTENDED FOR RESEARCH AND EDUCATIONAL PURPOSES ONLY. THIS
23: * SOFTWARE SHOULD NOT BE CONSIDERED TO BE A COMMERCIAL PRODUCT.
24: * THE DEVELOPER URGES THAT USERS WHO REQUIRE A COMMERCIAL PRODUCT
25: * NOT MAKE USE OF THIS WORK.
26: *
27: * FOR USERS WHO WISH TO UNDERSTAND THE 386BSD SYSTEM DEVELOPED
28: * BY WILLIAM F. JOLITZ, WE RECOMMEND THE USER STUDY WRITTEN
29: * REFERENCES SUCH AS THE "PORTING UNIX TO THE 386" SERIES
30: * (BEGINNING JANUARY 1991 "DR. DOBBS JOURNAL", USA AND BEGINNING
31: * JUNE 1991 "UNIX MAGAZIN", GERMANY) BY WILLIAM F. JOLITZ AND
32: * LYNNE GREER JOLITZ, AS WELL AS OTHER BOOKS ON UNIX AND THE
33: * ON-LINE 386BSD USER MANUAL BEFORE USE. A BOOK DISCUSSING THE INTERNALS
34: * OF 386BSD ENTITLED "386BSD FROM THE INSIDE OUT" WILL BE AVAILABLE LATE 1992.
35: *
36: * THIS SOFTWARE IS PROVIDED BY THE DEVELOPER ``AS IS'' AND
37: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
38: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
39: * ARE DISCLAIMED. IN NO EVENT SHALL THE DEVELOPER BE LIABLE
40: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
41: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
42: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
43: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
44: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
45: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
46: * SUCH DAMAGE.
47: *
48: */
49: */
50:
51: /*
52: * Device Driver for AT parallel printer port
53: * Written by William Jolitz 12/18/90
54: */
55:
56: #include "lpt.h"
57: #if NLPT > 0
58:
59: #include "param.h"
60: #include "user.h"
61: #include "buf.h"
62: #include "systm.h"
63: #include "kernel.h"
64: #include "ioctl.h"
65: #include "tty.h"
66: #include "uio.h"
67:
68: #include "i386/isa/isa_device.h"
69: #include "i386/isa/lptreg.h"
70:
71: #define LPINITRDY 4 /* wait up to 4 seconds for a ready */
72: #define LPTOUTTIME 4 /* wait up to 4 seconds for a ready */
73: #define LPPRI (PZERO+8)
74: #define BUFSIZE 1024
75:
76: #ifndef DEBUG
77: #define lprintf
78: #else
79: #define lprintf if (lpflag) printf
80: #endif
81:
82: int lptout();
83: #ifdef DEBUG
84: int lpflag = 1;
85: #endif
86:
87: int lptprobe(), lptattach(), lptintr();
88:
89: struct isa_driver lptdriver = {
90: lptprobe, lptattach, "lpt"
91: };
92:
93: #define LPTUNIT(s) (((s)>>6)&0x3)
94: #define LPTFLAGS(s) ((s)&0x3f)
95:
96: struct lpt_softc {
97: short sc_port;
98: short sc_state;
99: /* default case: negative prime, negative ack, handshake strobe,
100: prime once */
101: u_char sc_control;
102: char sc_flags;
103: #define LP_POS_INIT 0x01 /* if we are a postive init signal */
104: #define LP_POS_ACK 0x02 /* if we are a positive going ack */
105: #define LP_NO_PRIME 0x04 /* don't prime the printer at all */
106: #define LP_PRIMEOPEN 0x08 /* prime on every open */
107: #define LP_AUTOLF 0x10 /* tell printer to do an automatic lf */
108: #define LP_BYPASS 0x20 /* bypass printer ready checks */
109: struct buf *sc_inbuf;
110: short sc_xfercnt ;
111: char sc_primed;
112: char *sc_cp ;
113: } lpt_sc[NLPT] ;
114:
115: /* bits for state */
116: #define OPEN (1<<0) /* device is open */
117: #define ASLP (1<<1) /* awaiting draining of printer */
118: #define ERROR (1<<2) /* error was received from printer */
119: #define OBUSY (1<<3) /* printer is busy doing output */
120: #define LPTOUT (1<<4) /* timeout while not selected */
121: #define TOUT (1<<5) /* timeout while not selected */
122: #define INIT (1<<6) /* waiting to initialize for open */
123:
124: lptprobe(idp)
125: struct isa_device *idp;
126: { unsigned v;
127:
128: outb(idp->id_iobase+lpt_status,0xf0);
129: v = inb(idp->id_iobase+lpt_status);
130: outb(idp->id_iobase+lpt_status,0);
131: if (inb(idp->id_iobase+lpt_status) == v) {
132: outb(idp->id_iobase+lpt_control,0xff);
133: DELAY(100);
134: if (inb(idp->id_iobase+lpt_control) != 0xff)
135: return(0);
136: outb(idp->id_iobase+lpt_control,0);
137: DELAY(100);
138: if (inb(idp->id_iobase+lpt_control) != 0xe0)
139: return(0);
140: return(1);
141: }
142: return(0);
143: }
144:
145: lptattach(isdp)
146: struct isa_device *isdp;
147: {
148: struct lpt_softc *sc;
149:
150: sc = lpt_sc + isdp->id_unit;
151: sc->sc_port = isdp->id_iobase;
152: outb(sc->sc_port+lpt_control, LPC_NINIT);
153: return (1);
154: }
155:
156: /*
157: * lptopen -- reset the printer, then wait until it's selected and not busy.
158: */
159:
160: lptopen(dev, flag)
161: dev_t dev;
162: int flag;
163: {
164: struct lpt_softc *sc = lpt_sc + LPTUNIT(minor(dev));
165: int s;
166: int trys, port;
167:
168: if (sc->sc_state) {
169: lprintf("lp: still open\n") ;
170: printf("still open %x\n", sc->sc_state);
171: return(EBUSY);
172: } else sc->sc_state |= INIT;
173:
174: s = spltty();
175: sc->sc_flags = LPTFLAGS(minor(dev));
176: lprintf("lp flags 0x%x\n", sc->sc_flags);
177: port = sc->sc_port;
178:
179: /* init printer */
180: if((sc->sc_flags & LP_NO_PRIME) == 0) {
181: if((sc->sc_flags & LP_PRIMEOPEN) || sc->sc_primed == 0) {
182: outb(port+lpt_control, 0);
183: sc->sc_primed++;
184: DELAY(500);
185: }
186: }
187: outb(port+lpt_control, LPC_SEL|LPC_NINIT);
188:
189: /* wait till ready (printer running diagnostics) */
190: trys = 0;
191: do {
192: /* ran out of waiting for the printer */
193: if (trys++ >= LPINITRDY*4) {
194: splx(s);
195: sc->sc_state = 0;
196: printf ("status %x\n", inb(port+lpt_status) );
197: return (EBUSY);
198: }
199:
200: /* wait 1/4 second, give up if we get a signal */
201: if (tsleep (sc, LPPRI|PCATCH, "lptinit", hz/4) != EWOULDBLOCK) {
202: sc->sc_state = 0;
203: splx(s);
204: return (EBUSY);
205: }
206:
207: /* is printer online and ready for output */
208: } while ((inb(port+lpt_status) & (LPS_SEL|LPS_OUT|LPS_NBSY|LPS_NERR)) !=
209: (LPS_SEL|LPS_NBSY|LPS_NERR));
210:
211: if(sc->sc_flags&LP_AUTOLF) {
212: outb(port+lpt_control, LPC_SEL|LPC_NINIT|LPC_ENA|LPC_AUTOL);
213: sc->sc_control = LPC_SEL|LPC_NINIT|LPC_ENA|LPC_AUTOL;
214: } else {
215: outb(port+lpt_control, LPC_SEL|LPC_NINIT|LPC_ENA);
216: sc->sc_control = LPC_SEL|LPC_NINIT|LPC_ENA;
217: }
218:
219: sc->sc_state = OPEN | TOUT;
220: sc->sc_inbuf = geteblk(BUFSIZE);
221: sc->sc_xfercnt = 0;
222: splx(s);
223: timeout (lptout, sc, hz/2);
224: lprintf("opened.\n");
225: return(0);
226: }
227:
228: lptout (sc)
229: struct lpt_softc *sc;
230: { int pl;
231:
232: lprintf ("T %x ", inb(sc->sc_port+lpt_status));
233: if (sc->sc_state&OPEN)
234: timeout (lptout, sc, hz/2);
235: else sc->sc_state &= ~TOUT;
236:
237: if (sc->sc_state & ERROR)
238: sc->sc_state &= ~ERROR;
239:
240: /*
241: * Avoid possible hangs do to missed interrupts
242: */
243: if (sc->sc_xfercnt) {
244: pl = spltty();
245: lptintr(sc - lpt_sc);
246: splx(pl);
247: } else {
248: sc->sc_state &= ~OBUSY;
249: wakeup((caddr_t)sc);
250: }
251: }
252:
253: /*
254: * lptclose -- close the device, free the local line buffer.
255: */
256:
257: lptclose(dev, flag)
258: int flag;
259: {
260: struct lpt_softc *sc = lpt_sc + LPTUNIT(minor(dev));
261: int port = sc->sc_port;
262:
263: sc->sc_state &= ~OPEN;
264: while ((inb(port+lpt_status) & (LPS_SEL|LPS_OUT|LPS_NBSY|LPS_NERR)) !=
265: (LPS_SEL|LPS_NBSY|LPS_NERR) || sc->sc_xfercnt)
266: /* wait 1/4 second, give up if we get a signal */
267: if (tsleep (sc, LPPRI|PCATCH, "lpclose", hz) != EWOULDBLOCK)
268: break;
269:
270: sc->sc_state = 0;
271: sc->sc_xfercnt = 0;
272: outb(sc->sc_port+lpt_control, LPC_NINIT);
273: brelse(sc->sc_inbuf);
274: lprintf("closed.\n");
275: return(0);
276: }
277:
278: /*
279: * lptwrite --copy a line from user space to a local buffer, then call
280: * putc to get the chars moved to the output queue.
281: */
282:
283: lptwrite(dev, uio)
284: dev_t dev;
285: struct uio *uio;
286: {
287: register unsigned n;
288: int pl, err;
289: struct lpt_softc *sc = lpt_sc + LPTUNIT(minor(dev));
290:
291: while (n = MIN(BUFSIZE, uio->uio_resid)) {
292: sc->sc_cp = sc->sc_inbuf->b_un.b_addr ;
293: uiomove(sc->sc_cp, n, uio);
294: sc->sc_xfercnt = n ;
295: while (sc->sc_xfercnt > 0) {
296: /* if the printer is ready for a char, give it one */
297: if ((sc->sc_state & OBUSY) == 0){
298: lprintf("\nC %d. ", sc->sc_xfercnt);
299: pl = spltty();
300: lptintr(sc - lpt_sc);
301: (void) splx(pl);
302: }
303: lprintf("W ");
304: if (err = tsleep (sc, LPPRI|PCATCH, "lpwrite", 0))
305: return(err);
306: }
307: }
308: return(0);
309: }
310:
311: /*
312: * lptintr -- handle printer interrupts which occur when the printer is
313: * ready to accept another char.
314: */
315:
316: lptintr(unit)
317: {
318: struct lpt_softc *sc = lpt_sc + unit;
319: int port = sc->sc_port,sts;
320:
321: /* is printer online and ready for output */
322: if (((sts=inb(port+lpt_status)) & (LPS_SEL|LPS_OUT|LPS_NBSY|LPS_NERR/*|LPS_NACK*/)) ==
323: (LPS_SEL|LPS_NBSY|LPS_NERR)) {
324: /* is this a false interrupt ? */
325: if ((sc->sc_state & OBUSY)
326: && (sts & LPS_NACK) == 0) return;
327: sc->sc_state |= OBUSY; sc->sc_state &= ~ERROR;
328:
329: if (sc->sc_xfercnt) {
330: /* send char */
331: /*lprintf("%x ", *sc->sc_cp); */
332: outb(port+lpt_data, *sc->sc_cp++) ; sc->sc_xfercnt-- ;
333: outb(port+lpt_control, sc->sc_control|LPC_STB);
334: /* DELAY(X) */
335: outb(port+lpt_control, sc->sc_control);
336: }
337:
338: /* any more bytes for the printer? */
339: if (sc->sc_xfercnt > 0) return;
340:
341: /* none, wake up the top half to get more */
342: sc->sc_state &= ~OBUSY;
343: wakeup((caddr_t)sc);
344: lprintf("w ");
345: return;
346: } else sc->sc_state |= ERROR;
347: lprintf("sts %x ", sts);
348: }
349:
350: #endif NLP
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.