![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to lp.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / d / PS2_KERNEL / io.386|
Return to lp.c CVS log | Up to [MW Coherent from dump] / coherent / d / PS2_KERNEL / io.386 |
1.1 root 1: /*
2: * This is a driver for PC parallel printers.
3: * It has been tested on an EPSON MX-80, Printronix P300, HP LaserJet II.
4: * Supports up to three line printers.
5: */
6: #include <sys/coherent.h>
7: #ifdef _I386
8: #include <sys/reg.h>
9: #else
10: #include <sys/i8086.h>
11: #endif
12: #include <sys/con.h>
13: #include <sys/devices.h>
14: #include <errno.h>
15: #include <sys/io.h>
16: #include <sys/proc.h>
17: #include <sys/stat.h>
18:
19: /*
20: * Patchable parameters.
21: *
22: * LP0_OK specifies whether LP0 is always THERE.
23: * LPTIME specifies number of ticks between polls.
24: * LPWAIT specifies loop counter to wait in poll.
25: * LPTEST specifies whether or not to test for on-line conditition.
26: */
27: int LP0_OK = 0;
28: int LPTIME = 4;
29: int LPWAIT = 400;
30: int LPTEST = 1;
31:
32: /*
33: * Driver configuration.
34: */
35: int lpload();
36: int lpunload();
37: int lpwrite();
38: int lpopen();
39: int lpclose();
40: int lpintr();
41: int nulldev();
42: int nonedev();
43:
44: CON lpcon = {
45: DFCHR, /* Flags */
46: LP_MAJOR, /* Major index */
47: lpopen, /* Open */
48: lpclose, /* Close */
49: nulldev, /* Block */
50: nonedev, /* Read */
51: lpwrite, /* Write */
52: nonedev, /* Ioctl */
53: nulldev, /* Powerfail */
54: nulldev, /* Timeout */
55: lpload, /* Load */
56: lpunload /* Unload */
57: };
58:
59: /*
60: * Line Printer Registers.
61: */
62: #define LPDAT (0) /* Data port, lpbase + 0 */
63: #define LPSTR (1) /* Status port, lpbase + 1 */
64: #define LPCSR (2) /* Control port, lpbase + 2 */
65:
66: /*
67: * LP Flag Bits.
68: */
69: #define LPTHERE 0x01 /* Interface actually there */
70: #define LPOPEN 0x02 /* Printer is open */
71: #define LPSLEEP 0x04 /* Sleeping on buffer event */
72: #define LPRAW 0x80 /* Raw mode */
73:
74: /*
75: * Printer database.
76: * Terminated by lpbase = 0.
77: * NLP = # entries - 1.
78: */
79: static struct lpinfo {
80: int lpbase; /* I/O Base address */
81: int lpflag; /* Flags */
82: int lpcol; /* Current horizontal position */
83: } lpinfo[] = {
84: { 0x3BC },
85: { 0x378 },
86: { 0x278 },
87: { 0x000 }
88: };
89: #define NLP (sizeof(lpinfo) / sizeof(lpinfo[0]) - 1)
90:
91: /*
92: * LP Status Register Bits.
93: */
94: #define ACK 0x80 /* Ack (active high) */
95: #define BUSY 0x40 /* Busy (active high) */
96: #define NOPAPER 0x20 /* No paper */
97: #define ONLINE 0x10 /* On line */
98: #define NERROR 0x08 /* Error (active low) */
99:
100: /* IBM cable */
101: #define IBMNBSY 0x80 /* Busy (active low) */
102: #define IBMNACK 0x40 /* Ack (active low) */
103:
104: /*
105: * LP Control Register Bits.
106: */
107: #define IENABLE 0x10 /* Interrupt enable */
108: #define SEL 0x08 /* Select input */
109: #define NINIT 0x04 /* Initialise printer (active low) */
110: #define AFEED 0x02 /* Auto line feed */
111: #define STROBE 0x01 /* Strobe */
112:
113: /*
114: * On load
115: * compute the port addresses,
116: * reset the printer, and select it.
117: */
118: static
119: lpload()
120: {
121: register struct lpinfo * p;
122: register int delay;
123: static int notfirst;
124:
125: /*
126: * Only initialize hardware on first invocation.
127: * Necessary if used as console device [condev].
128: */
129: if ( notfirst )
130: return;
131: notfirst = 1;
132:
133: /*
134: * Note: since some PC clones lp ports can't be read,
135: * their lpflag field has to be patched to 'LPTHERE'.
136: */
137: if ( LP0_OK & 1 )
138: lpinfo[0].lpflag |= LPTHERE;
139: if ( LP0_OK & 2 )
140: lpinfo[1].lpflag |= LPTHERE;
141: if ( LP0_OK & 4 )
142: lpinfo[2].lpflag |= LPTHERE;
143:
144: for ( p = lpinfo; p->lpbase ; ++p ) {
145:
146: /*
147: * Check printer port existence.
148: */
149: if ( (p->lpflag & LPTHERE) == 0 ) {
150: outb( p->lpbase+LPDAT, 0xA5 );
151: delay = LPWAIT; do {
152: } while (--delay);
153: if ( inb(p->lpbase+LPDAT) == 0xA5 )
154: p->lpflag |= LPTHERE;
155: }
156:
157: /*
158: * Initialize and select printer.
159: */
160: outb( p->lpbase+LPCSR, SEL );
161: delay = LPWAIT; do {
162: } while (--delay);
163: outb( p->lpbase+LPCSR, SEL|NINIT );
164: }
165: }
166:
167: /*
168: * On unload
169: * cancel any timed functions.
170: */
171: static
172: lpunload()
173: {
174: lptimer();
175: }
176:
177: /*
178: * The open routine makes sure that
179: * only one process has the printer open
180: * at one time, and not too much else.
181: */
182: static
183: lpopen(dev, mode)
184: dev_t dev;
185: {
186: register struct lpinfo * p;
187:
188: /*
189: * Illegal printer port.
190: */
191: if ( (minor(dev) & ~LPRAW) >= NLP ) {
192: u.u_error = ENXIO;
193: return;
194: }
195:
196: /*
197: * Access attributes.
198: */
199: p = &lpinfo[ minor(dev) & ~LPRAW ];
200:
201: /*
202: * Attempt initialization if printer port not found.
203: */
204: if ( (p->lpflag&LPTHERE) == 0 )
205: lpload();
206:
207: /*
208: * Printer port not found.
209: */
210: if ( (p->lpflag&LPTHERE) == 0 ) {
211: u.u_error = ENXIO;
212: return;
213: }
214:
215: /*
216: * Printer port already open.
217: */
218: if ( (p->lpflag&LPOPEN) != 0 ) {
219: #ifdef _I386
220: u.u_error = EBUSY;
221: #else
222: u.u_error = EDBUSY;
223: #endif
224: return;
225: }
226:
227: /*
228: * Printer powered off or off-line
229: */
230: if (LPTEST && !(inb(p->lpbase+LPSTR) & ONLINE)) {
231: #ifdef _I386
232: u.u_error = EIO;
233: #else
234: u.u_error = EDATTN;
235: #endif
236: return;
237: }
238:
239: /*
240: * Flag port as being open.
241: */
242: p->lpflag &= ~LPRAW;
243: p->lpflag |= LPOPEN | minor(dev) & LPRAW;
244:
245: /*
246: * Initiate periodic printer scan if user open.
247: */
248: if ( (SELF != NULL) && (SELF->p_pid != 0) )
249: lptimer();
250: }
251:
252: /*
253: * The close routine marks the device as no longer open.
254: */
255: static
256: lpclose(dev)
257: dev_t dev;
258: {
259: lpinfo[ minor(dev) & ~LPRAW ].lpflag &= ~LPOPEN;
260: }
261:
262: /*
263: * The write routine copies the
264: * characters from the user buffer to
265: * the printer buffer, expanding tabs and
266: * keeping track of the current horizontal
267: * position of the print head.
268: */
269: static
270: lpwrite( dev, iop )
271: dev_t dev;
272: IO *iop;
273: {
274: register struct lpinfo * p;
275: register int c;
276:
277: p = &lpinfo[ minor(dev) & ~LPRAW ];
278:
279: /*
280: * Writes from kernel are handled via busy-waits instead of timeouts.
281: */
282: if (iop->io_seg == IOSYS) {
283:
284: while ( (c=iogetc(iop)) >= 0 ) {
285:
286: while ( (inb(p->lpbase+LPSTR) & IBMNBSY) == 0 )
287: ;
288:
289: outb( p->lpbase+LPDAT, c );
290: outb( p->lpbase+LPCSR, SEL|NINIT|STROBE );
291: outb( p->lpbase+LPCSR, SEL|NINIT );
292: }
293: return;
294: }
295:
296: /*
297: * Writes from user are handled via lpchar() which uses timeouts.
298: */
299: while ( (c=iogetc(iop)) >= 0 ) {
300:
301: if ( (p->lpflag&LPRAW) == 0 ) {
302:
303: switch (c) {
304:
305: case '\t':
306: do {
307: lpchar( p, ' ');
308: } while ((++p->lpcol&07) != 0);
309: continue;
310:
311: case '\n':
312: lpchar( p, '\r');
313: /* no break */
314:
315: case '\r':
316: case '\f':
317: p->lpcol = 0;
318: break;
319:
320: case '\b':
321: --p->lpcol;
322: break;
323:
324: default:
325: ++p->lpcol;
326: }
327: }
328: lpchar( p, c );
329:
330: if ( SELF->p_ssig!=0 && nondsig() ) {
331: u.u_error = EINTR;
332: break;
333: }
334: }
335: }
336:
337: /*
338: * Put a character into the printer buffer.
339: * If the printer doesn't respond ready in a reasonable time
340: * sleep for a while.
341: */
342: static
343: lpchar( p, c )
344: register struct lpinfo *p;
345: int c;
346: {
347: register int s;
348:
349: s = LPWAIT;
350: while ( (inb(p->lpbase+LPSTR) & IBMNBSY) == 0 ) {
351: if ( --s == 0 ) {
352: s = sphi();
353: p->lpflag |= LPSLEEP;
354: sleep((char *)p, 0, 0, 0);
355: spl(s);
356: s = LPWAIT;
357: }
358: }
359:
360: outb( p->lpbase+LPDAT, c );
361: outb( p->lpbase+LPCSR, SEL|NINIT|STROBE );
362: outb( p->lpbase+LPCSR, SEL|NINIT );
363: }
364:
365: /*
366: * Poll the line printer interface from the clock.
367: * Turn it off when there is nothing left to do.
368: */
369: static
370: lptimer()
371: {
372: register struct lpinfo *p;
373: int isopen = 0;
374: static TIM tim;
375:
376: /*
377: * Scan all printers.
378: */
379: for ( p = lpinfo; p->lpbase; ++p ) {
380:
381: /*
382: * Ignore unopened printers.
383: */
384: if ( (p->lpflag & LPOPEN) == 0 )
385: continue;
386:
387: ++isopen;
388:
389: /*
390: * Check for sleeping process on ready printer.
391: */
392: if((p->lpflag & LPSLEEP) && (inb(p->lpbase+LPSTR) & IBMNBSY)){
393: p->lpflag &= ~LPSLEEP;
394: wakeup((char *)p);
395: }
396: }
397:
398: /*
399: * Reschedule timer function if at least 1 printer is still open.
400: */
401: if ( isopen )
402: timeout( &tim, LPTIME, lptimer, &tim );
403: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.