xref: /netbsd-src/sys/dev/ic/lpt.c (revision d1579b2d70337e1b895f03478838f880e450f6da)
1 /*	$NetBSD: lpt.c,v 1.82 2018/09/03 16:29:31 riastradh Exp $	*/
2 
3 /*
4  * Copyright (c) 1993, 1994 Charles M. Hannum.
5  * Copyright (c) 1990 William F. Jolitz, TeleMuse
6  * All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the
15  *    documentation and/or other materials provided with the distribution.
16  * 3. All advertising materials mentioning features or use of this software
17  *    must display the following acknowledgement:
18  *	This software is a component of "386BSD" developed by
19  *	William F. Jolitz, TeleMuse.
20  * 4. Neither the name of the developer nor the name "386BSD"
21  *    may be used to endorse or promote products derived from this software
22  *    without specific prior written permission.
23  *
24  * THIS SOFTWARE IS A COMPONENT OF 386BSD DEVELOPED BY WILLIAM F. JOLITZ
25  * AND IS INTENDED FOR RESEARCH AND EDUCATIONAL PURPOSES ONLY. THIS
26  * SOFTWARE SHOULD NOT BE CONSIDERED TO BE A COMMERCIAL PRODUCT.
27  * THE DEVELOPER URGES THAT USERS WHO REQUIRE A COMMERCIAL PRODUCT
28  * NOT MAKE USE OF THIS WORK.
29  *
30  * FOR USERS WHO WISH TO UNDERSTAND THE 386BSD SYSTEM DEVELOPED
31  * BY WILLIAM F. JOLITZ, WE RECOMMEND THE USER STUDY WRITTEN
32  * REFERENCES SUCH AS THE  "PORTING UNIX TO THE 386" SERIES
33  * (BEGINNING JANUARY 1991 "DR. DOBBS JOURNAL", USA AND BEGINNING
34  * JUNE 1991 "UNIX MAGAZIN", GERMANY) BY WILLIAM F. JOLITZ AND
35  * LYNNE GREER JOLITZ, AS WELL AS OTHER BOOKS ON UNIX AND THE
36  * ON-LINE 386BSD USER MANUAL BEFORE USE. A BOOK DISCUSSING THE INTERNALS
37  * OF 386BSD ENTITLED "386BSD FROM THE INSIDE OUT" WILL BE AVAILABLE LATE 1992.
38  *
39  * THIS SOFTWARE IS PROVIDED BY THE DEVELOPER ``AS IS'' AND
40  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
41  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
42  * ARE DISCLAIMED.  IN NO EVENT SHALL THE DEVELOPER BE LIABLE
43  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
44  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
45  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
46  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
47  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
48  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
49  * SUCH DAMAGE.
50  */
51 
52 /*
53  * Device Driver for AT style parallel printer port
54  */
55 
56 #include <sys/cdefs.h>
57 __KERNEL_RCSID(0, "$NetBSD: lpt.c,v 1.82 2018/09/03 16:29:31 riastradh Exp $");
58 
59 #include <sys/param.h>
60 #include <sys/systm.h>
61 #include <sys/proc.h>
62 #include <sys/malloc.h>
63 #include <sys/kernel.h>
64 #include <sys/ioctl.h>
65 #include <sys/uio.h>
66 #include <sys/device.h>
67 #include <sys/conf.h>
68 #include <sys/syslog.h>
69 #include <sys/intr.h>
70 
71 #include <sys/bus.h>
72 
73 #include <dev/ic/lptreg.h>
74 #include <dev/ic/lptvar.h>
75 
76 #include "ioconf.h"
77 
78 #define	TIMEOUT		hz*16	/* wait up to 16 seconds for a ready */
79 #define	STEP		hz/4
80 
81 #define	LPTPRI		(PZERO+8)
82 #define	LPT_BSIZE	1024
83 
84 #define LPTDEBUG
85 
86 #ifndef LPTDEBUG
87 #define LPRINTF(a)
88 #else
89 #define LPRINTF(a)	if (lptdebug) printf a
90 int lptdebug = 0;
91 #endif
92 
93 dev_type_open(lptopen);
94 dev_type_close(lptclose);
95 dev_type_write(lptwrite);
96 dev_type_ioctl(lptioctl);
97 
98 const struct cdevsw lpt_cdevsw = {
99 	.d_open = lptopen,
100 	.d_close = lptclose,
101 	.d_read = noread,
102 	.d_write = lptwrite,
103 	.d_ioctl = lptioctl,
104 	.d_stop = nostop,
105 	.d_tty = notty,
106 	.d_poll = nopoll,
107 	.d_mmap = nommap,
108 	.d_kqfilter = nokqfilter,
109 	.d_discard = nodiscard,
110 	.d_flag = D_OTHER
111 };
112 
113 #define	LPTUNIT(s)	(minor(s) & 0x1f)
114 #define	LPTFLAGS(s)	(minor(s) & 0xe0)
115 
116 static void	lptsoftintr(void *);
117 
118 void
lpt_attach_subr(struct lpt_softc * sc)119 lpt_attach_subr(struct lpt_softc *sc)
120 {
121 	bus_space_tag_t iot;
122 	bus_space_handle_t ioh;
123 
124 	sc->sc_state = 0;
125 
126 	iot = sc->sc_iot;
127 	ioh = sc->sc_ioh;
128 
129 	bus_space_write_1(iot, ioh, lpt_control, LPC_NINIT);
130 
131 	callout_init(&sc->sc_wakeup_ch, 0);
132 	sc->sc_sih = softint_establish(SOFTINT_SERIAL, lptsoftintr, sc);
133 
134 	sc->sc_dev_ok = 1;
135 }
136 
137 int
lpt_detach_subr(device_t self,int flags)138 lpt_detach_subr(device_t self, int flags)
139 {
140 	struct lpt_softc *sc = device_private(self);
141 
142 	sc->sc_dev_ok = 0;
143 	softint_disestablish(sc->sc_sih);
144 	callout_destroy(&sc->sc_wakeup_ch);
145 	return 0;
146 }
147 
148 /*
149  * Reset the printer, then wait until it's selected and not busy.
150  */
151 int
lptopen(dev_t dev,int flag,int mode,struct lwp * l)152 lptopen(dev_t dev, int flag, int mode, struct lwp *l)
153 {
154 	u_char flags = LPTFLAGS(dev);
155 	struct lpt_softc *sc;
156 	bus_space_tag_t iot;
157 	bus_space_handle_t ioh;
158 	u_char control;
159 	int error;
160 	int spin;
161 
162 	sc = device_lookup_private(&lpt_cd, LPTUNIT(dev));
163 	if (!sc || !sc->sc_dev_ok)
164 		return ENXIO;
165 
166 #if 0	/* XXX what to do? */
167 	if (sc->sc_irq == IRQUNK && (flags & LPT_NOINTR) == 0)
168 		return ENXIO;
169 #endif
170 
171 #ifdef DIAGNOSTIC
172 	if (sc->sc_state)
173 		aprint_verbose_dev(sc->sc_dev, "stat=0x%x not zero\n",
174 		    sc->sc_state);
175 #endif
176 
177 	if (sc->sc_state)
178 		return EBUSY;
179 
180 	sc->sc_state = LPT_INIT;
181 	sc->sc_flags = flags;
182 	LPRINTF(("%s: open: flags=0x%x\n", device_xname(sc->sc_dev),
183 	    (unsigned)flags));
184 	iot = sc->sc_iot;
185 	ioh = sc->sc_ioh;
186 
187 	if ((flags & LPT_NOPRIME) == 0) {
188 		/* assert INIT for 100 usec to start up printer */
189 		bus_space_write_1(iot, ioh, lpt_control, LPC_SELECT);
190 		delay(100);
191 	}
192 
193 	control = LPC_SELECT | LPC_NINIT;
194 	bus_space_write_1(iot, ioh, lpt_control, control);
195 
196 	/* wait till ready (printer running diagnostics) */
197 	for (spin = 0; NOT_READY_ERR(); spin += STEP) {
198 		if (spin >= TIMEOUT) {
199 			sc->sc_state = 0;
200 			return EBUSY;
201 		}
202 
203 		/* wait 1/4 second, give up if we get a signal */
204 		error = tsleep((void *)sc, LPTPRI | PCATCH, "lptopen", STEP);
205 		if (error != EWOULDBLOCK) {
206 			sc->sc_state = 0;
207 			return error;
208 		}
209 	}
210 
211 	if ((flags & LPT_NOINTR) == 0)
212 		control |= LPC_IENABLE;
213 	if (flags & LPT_AUTOLF)
214 		control |= LPC_AUTOLF;
215 	sc->sc_control = control;
216 	bus_space_write_1(iot, ioh, lpt_control, control);
217 
218 	sc->sc_inbuf = malloc(LPT_BSIZE, M_DEVBUF, M_WAITOK);
219 	sc->sc_count = 0;
220 	sc->sc_state = LPT_OPEN;
221 
222 	if ((sc->sc_flags & LPT_NOINTR) == 0)
223 		lptwakeup(sc);
224 
225 	LPRINTF(("%s: opened\n", device_xname(sc->sc_dev)));
226 	return 0;
227 }
228 
229 int
lptnotready(u_char status,struct lpt_softc * sc)230 lptnotready(u_char status, struct lpt_softc *sc)
231 {
232 	u_char new;
233 
234 	status = (status ^ LPS_INVERT) & LPS_MASK;
235 	new = status & ~sc->sc_laststatus;
236 	sc->sc_laststatus = status;
237 
238 	if (sc->sc_state & LPT_OPEN) {
239 		if (new & LPS_SELECT)
240 			log(LOG_NOTICE,
241 			    "%s: offline\n", device_xname(sc->sc_dev));
242 		else if (new & LPS_NOPAPER)
243 			log(LOG_NOTICE,
244 			    "%s: out of paper\n", device_xname(sc->sc_dev));
245 		else if (new & LPS_NERR)
246 			log(LOG_NOTICE,
247 			    "%s: output error\n", device_xname(sc->sc_dev));
248 	}
249 
250 	return status;
251 }
252 
253 void
lptwakeup(void * arg)254 lptwakeup(void *arg)
255 {
256 	struct lpt_softc *sc = arg;
257 	int s;
258 
259 	s = splvm();
260 	lptintr(sc);
261 	splx(s);
262 
263 	callout_reset(&sc->sc_wakeup_ch, STEP, lptwakeup, sc);
264 }
265 
266 /*
267  * Close the device, and free the local line buffer.
268  */
269 int
lptclose(dev_t dev,int flag,int mode,struct lwp * l)270 lptclose(dev_t dev, int flag, int mode,
271     struct lwp *l)
272 {
273 	struct lpt_softc *sc =
274 	    device_lookup_private(&lpt_cd, LPTUNIT(dev));
275 	bus_space_tag_t iot = sc->sc_iot;
276 	bus_space_handle_t ioh = sc->sc_ioh;
277 
278 	if (sc->sc_count)
279 		(void) lptpushbytes(sc);
280 
281 	if ((sc->sc_flags & LPT_NOINTR) == 0)
282 		callout_stop(&sc->sc_wakeup_ch);
283 
284 	bus_space_write_1(iot, ioh, lpt_control, LPC_NINIT);
285 	sc->sc_state = 0;
286 	bus_space_write_1(iot, ioh, lpt_control, LPC_NINIT);
287 	free(sc->sc_inbuf, M_DEVBUF);
288 
289 	LPRINTF(("%s: closed\n", device_xname(sc->sc_dev)));
290 	return 0;
291 }
292 
293 int
lptpushbytes(struct lpt_softc * sc)294 lptpushbytes(struct lpt_softc *sc)
295 {
296 	bus_space_tag_t iot = sc->sc_iot;
297 	bus_space_handle_t ioh = sc->sc_ioh;
298 	int error;
299 
300 	if (sc->sc_flags & LPT_NOINTR) {
301 		int spin, tic;
302 		u_char control = sc->sc_control;
303 
304 		while (sc->sc_count > 0) {
305 			spin = 0;
306 			while (NOT_READY()) {
307 				if (++spin < sc->sc_spinmax)
308 					continue;
309 				tic = 0;
310 				/* adapt busy-wait algorithm */
311 				sc->sc_spinmax++;
312 				while (NOT_READY_ERR()) {
313 					/* exponential backoff */
314 					tic = tic + tic + 1;
315 					if (tic > TIMEOUT)
316 						tic = TIMEOUT;
317 					error = tsleep((void *)sc,
318 					    LPTPRI | PCATCH, "lptpsh", tic);
319 					if (error != EWOULDBLOCK)
320 						return error;
321 				}
322 				break;
323 			}
324 
325 			bus_space_write_1(iot, ioh, lpt_data, *sc->sc_cp++);
326 			DELAY(1);
327 			bus_space_write_1(iot, ioh, lpt_control,
328 			    control | LPC_STROBE);
329 			DELAY(1);
330 			sc->sc_count--;
331 			bus_space_write_1(iot, ioh, lpt_control, control);
332 			DELAY(1);
333 
334 			/* adapt busy-wait algorithm */
335 			if (spin*2 + 16 < sc->sc_spinmax)
336 				sc->sc_spinmax--;
337 		}
338 	} else {
339 		int s;
340 
341 		while (sc->sc_count > 0) {
342 			/* if the printer is ready for a char, give it one */
343 			if ((sc->sc_state & LPT_OBUSY) == 0) {
344 				LPRINTF(("%s: write %lu\n",
345 				    device_xname(sc->sc_dev),
346 				    (u_long)sc->sc_count));
347 				s = splvm();
348 				(void) lptintr(sc);
349 				splx(s);
350 			}
351 			error = tsleep((void *)sc, LPTPRI | PCATCH,
352 			    "lptwrite2", 0);
353 			if (error)
354 				return error;
355 		}
356 	}
357 	return 0;
358 }
359 
360 /*
361  * Copy a line from user space to a local buffer, then call putc to get the
362  * chars moved to the output queue.
363  */
364 int
lptwrite(dev_t dev,struct uio * uio,int flags)365 lptwrite(dev_t dev, struct uio *uio, int flags)
366 {
367 	struct lpt_softc *sc =
368 	    device_lookup_private(&lpt_cd, LPTUNIT(dev));
369 	size_t n;
370 	int error = 0;
371 
372 	while ((n = uimin(LPT_BSIZE, uio->uio_resid)) != 0) {
373 		uiomove(sc->sc_cp = sc->sc_inbuf, n, uio);
374 		sc->sc_count = n;
375 		error = lptpushbytes(sc);
376 		if (error) {
377 			/*
378 			 * Return accurate residual if interrupted or timed
379 			 * out.
380 			 */
381 			uio->uio_resid += sc->sc_count;
382 			sc->sc_count = 0;
383 			return error;
384 		}
385 	}
386 	return 0;
387 }
388 
389 /*
390  * Handle printer interrupts which occur when the printer is ready to accept
391  * another char.
392  */
393 int
lptintr(void * arg)394 lptintr(void *arg)
395 {
396 	struct lpt_softc *sc = arg;
397 	bus_space_tag_t iot = sc->sc_iot;
398 	bus_space_handle_t ioh = sc->sc_ioh;
399 
400 #if 0
401 	if ((sc->sc_state & LPT_OPEN) == 0)
402 		return 0;
403 #endif
404 
405 	/* is printer online and ready for output */
406 	if (NOT_READY() && NOT_READY_ERR())
407 		return 0;
408 
409 	if (sc->sc_count) {
410 		u_char control = sc->sc_control;
411 		/* send char */
412 		bus_space_write_1(iot, ioh, lpt_data, *sc->sc_cp++);
413 		DELAY(1);
414 		bus_space_write_1(iot, ioh, lpt_control, control | LPC_STROBE);
415 		DELAY(1);
416 		sc->sc_count--;
417 		bus_space_write_1(iot, ioh, lpt_control, control);
418 		DELAY(1);
419 		sc->sc_state |= LPT_OBUSY;
420 	} else
421 		sc->sc_state &= ~LPT_OBUSY;
422 
423 	if (sc->sc_count == 0) {
424 		/* none, wake up the top half to get more */
425 		softint_schedule(sc->sc_sih);
426 	}
427 
428 	return 1;
429 }
430 
431 static void
lptsoftintr(void * cookie)432 lptsoftintr(void *cookie)
433 {
434 
435 	wakeup(cookie);
436 }
437 
438 int
lptioctl(dev_t dev,u_long cmd,void * data,int flag,struct lwp * l)439 lptioctl(dev_t dev, u_long cmd, void *data,
440     int flag, struct lwp *l)
441 {
442 	return ENODEV;
443 }
444