xref: /netbsd-src/sys/arch/atari/dev/ser.c (revision 3816d47b2c42fcd6e549e3407f842a5b1a1d23ad)
1 /*	$NetBSD: ser.c,v 1.45 2009/11/23 00:11:43 rmind Exp $	*/
2 
3 /*-
4  * Copyright (c) 1997 The NetBSD Foundation, Inc.
5  * All rights reserved.
6  *
7  * This code is derived from software contributed to The NetBSD Foundation
8  * by Leo Weppelman.
9  *
10  * Redistribution and use in source and binary forms, with or without
11  * modification, are permitted provided that the following conditions
12  * are met:
13  * 1. Redistributions of source code must retain the above copyright
14  *    notice, this list of conditions and the following disclaimer.
15  * 2. Redistributions in binary form must reproduce the above copyright
16  *    notice, this list of conditions and the following disclaimer in the
17  *    documentation and/or other materials provided with the distribution.
18  *
19  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
20  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
21  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
23  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29  * POSSIBILITY OF SUCH DAMAGE.
30  */
31 /*-
32  * Copyright (c) 1993, 1994, 1995, 1996, 1997
33  *      Charles M. Hannum.  All rights reserved.
34  *
35  * Interrupt processing and hardware flow control partly based on code from
36  * Onno van der Linden and Gordon Ross.
37  *
38  * Redistribution and use in source and binary forms, with or without
39  * modification, are permitted provided that the following conditions
40  * are met:
41  * 1. Redistributions of source code must retain the above copyright
42  *    notice, this list of conditions and the following disclaimer.
43  * 2. Redistributions in binary form must reproduce the above copyright
44  *    notice, this list of conditions and the following disclaimer in the
45  *    documentation and/or other materials provided with the distribution.
46  * 3. All advertising materials mentioning features or use of this software
47  *    must display the following acknowledgement:
48  *      This product includes software developed by Charles M. Hannum.
49  * 4. The name of the author may not be used to endorse or promote products
50  *    derived from this software without specific prior written permission.
51  *
52  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
53  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
54  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
55  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
56  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
57  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
58  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
59  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
60  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
61  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
62  */
63 
64 /*
65  * Copyright (c) 1991 The Regents of the University of California.
66  * All rights reserved.
67  *
68  * Redistribution and use in source and binary forms, with or without
69  * modification, are permitted provided that the following conditions
70  * are met:
71  * 1. Redistributions of source code must retain the above copyright
72  *    notice, this list of conditions and the following disclaimer.
73  * 2. Redistributions in binary form must reproduce the above copyright
74  *    notice, this list of conditions and the following disclaimer in the
75  *    documentation and/or other materials provided with the distribution.
76  * 3. Neither the name of the University nor the names of its contributors
77  *    may be used to endorse or promote products derived from this software
78  *    without specific prior written permission.
79  *
80  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
81  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
82  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
83  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
84  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
85  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
86  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
87  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
88  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
89  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
90  * SUCH DAMAGE.
91  *
92  *      @(#)com.c       7.5 (Berkeley) 5/16/91
93  */
94 
95 #include <sys/cdefs.h>
96 __KERNEL_RCSID(0, "$NetBSD: ser.c,v 1.45 2009/11/23 00:11:43 rmind Exp $");
97 
98 #include "opt_ddb.h"
99 #include "opt_mbtype.h"
100 #include "opt_serconsole.h"
101 
102 #include <sys/param.h>
103 #include <sys/systm.h>
104 #include <sys/ioctl.h>
105 #include <sys/select.h>
106 #include <sys/tty.h>
107 #include <sys/proc.h>
108 #include <sys/conf.h>
109 #include <sys/file.h>
110 #include <sys/uio.h>
111 #include <sys/kernel.h>
112 #include <sys/syslog.h>
113 #include <sys/types.h>
114 #include <sys/device.h>
115 #include <sys/kauth.h>
116 
117 #include <m68k/asm_single.h>
118 
119 #include <machine/iomap.h>
120 #include <machine/mfp.h>
121 #include <machine/intr.h>
122 #include <atari/dev/serreg.h>
123 
124 #if !defined(_MILANHW_)
125 #include <atari/dev/ym2149reg.h>
126 #else
127 	/* MILAN has no ym2149 */
128 #define ym2149_dtr(set) {					\
129 	if (set)						\
130 		single_inst_bset_b(MFP->mf_gpip, 0x08);		\
131 	else single_inst_bclr_b(MFP->mf_gpip, 0x08);		\
132 }
133 
134 #define ym2149_rts(set) {					\
135 	if (set)						\
136 		single_inst_bset_b(MFP->mf_gpip, 0x01);		\
137 	else single_inst_bclr_b(MFP->mf_gpip, 0x01);		\
138 }
139 #endif /* _MILANHW_ */
140 
141 /* #define SER_DEBUG */
142 
143 #define	SERUNIT(x)	(minor(x) & 0x7ffff)
144 #define	SERDIALOUT(x)	(minor(x) & 0x80000)
145 
146 /* XXX */
147 #define	CONSBAUD	9600
148 #define	CONSCFLAG	TTYDEF_CFLAG
149 /* end XXX */
150 
151 /* Buffer size for character buffer */
152 #define RXBUFSIZE 2048		/* More than enough..			*/
153 #define RXBUFMASK (RXBUFSIZE-1)	/* Only iff previous is a power of 2	*/
154 #define RXHIWAT   (RXBUFSIZE >> 2)
155 
156 struct ser_softc {
157 	struct device	 sc_dev;
158 	struct tty	*sc_tty;
159 
160 	struct callout sc_diag_ch;
161 
162 	int		 sc_overflows;
163 	int		 sc_floods;
164 	int		 sc_errors;
165 
166 	u_char		 sc_hwflags;
167 	u_char		 sc_swflags;
168 
169 	int		 sc_ospeed;		/* delay + timer-d data	*/
170 	u_char		 sc_imra;
171 	u_char		 sc_imrb;
172 	u_char		 sc_ucr;		/* Uart control		*/
173 	u_char		 sc_msr;		/* Modem status		*/
174 	u_char		 sc_tsr;		/* Tranceiver status	*/
175 	u_char		 sc_rsr;		/* Receiver status	*/
176 	u_char		 sc_mcr;		/* (Pseudo) Modem ctrl. */
177 
178 	u_char		 sc_msr_delta;
179 	u_char		 sc_msr_mask;
180 	u_char		 sc_mcr_active;
181 	u_char		 sc_mcr_dtr, sc_mcr_rts, sc_msr_cts, sc_msr_dcd;
182 
183 	int		 sc_r_hiwat;
184  	volatile u_int	 sc_rbget;
185  	volatile u_int	 sc_rbput;
186 	volatile u_int	 sc_rbavail;
187  	u_char		 sc_rbuf[RXBUFSIZE];
188 	u_char		 sc_lbuf[RXBUFSIZE];
189 
190 	volatile u_char	 sc_rx_blocked;
191 	volatile u_char	 sc_rx_ready;
192 	volatile u_char	 sc_tx_busy;
193 	volatile u_char	 sc_tx_done;
194 	volatile u_char	 sc_tx_stopped;
195 	volatile u_char	 sc_st_check;
196 
197  	u_char		*sc_tba;
198  	int		 sc_tbc;
199 	int		 sc_heldtbc;
200 
201 	volatile u_char	 sc_heldchange;
202 
203 	void		*sc_sicookie;
204 };
205 
206 /*
207  * For sc_hwflags:
208  */
209 #define	SER_HW_CONSOLE	0x01
210 
211 void	ser_break(struct ser_softc *, int);
212 void	ser_hwiflow(struct ser_softc *, int);
213 void	ser_iflush(struct ser_softc *);
214 void	ser_loadchannelregs(struct ser_softc *);
215 void	ser_modem(struct ser_softc *, int);
216 void	serdiag(void *);
217 int	serhwiflow(struct tty *, int);
218 void	serinit(int);
219 void	serinitcons(int);
220 int	sermintr(void *);
221 int	sertrintr(void *);
222 int	serparam(struct tty *, struct termios *);
223 void	serstart(struct tty *);
224 
225 struct consdev;
226 void	sercnprobe(struct consdev *);
227 void	sercninit(struct consdev *);
228 int	sercngetc(dev_t);
229 void	sercnputc(dev_t, int);
230 void	sercnpollc(dev_t, int);
231 
232 static void sermsrint(struct ser_softc *, struct tty*);
233 static void serrxint(struct ser_softc *, struct tty*);
234 static void ser_shutdown(struct ser_softc *);
235 static int serspeed(long);
236 static void sersoft(void *);
237 static void sertxint(struct ser_softc *, struct tty*);
238 
239 /*
240  * Autoconfig stuff
241  */
242 static void serattach(struct device *, struct device *, void *);
243 static int  sermatch(struct device *, struct cfdata *, void *);
244 
245 CFATTACH_DECL(ser, sizeof(struct ser_softc),
246     sermatch, serattach, NULL, NULL);
247 
248 extern struct cfdriver ser_cd;
249 
250 dev_type_open(seropen);
251 dev_type_close(serclose);
252 dev_type_read(serread);
253 dev_type_write(serwrite);
254 dev_type_ioctl(serioctl);
255 dev_type_stop(serstop);
256 dev_type_tty(sertty);
257 dev_type_poll(serpoll);
258 
259 const struct cdevsw ser_cdevsw = {
260 	seropen, serclose, serread, serwrite, serioctl,
261 	serstop, sertty, serpoll, nommap, ttykqfilter, D_TTY
262 };
263 
264 /*ARGSUSED*/
265 static	int
266 sermatch(struct device *pdp, struct cfdata *cfp, void *auxp)
267 {
268 	static int	ser_matched = 0;
269 
270 	/* Match at most one ser unit */
271 	if (strcmp((char *)auxp, "ser") || ser_matched)
272 		return 0;
273 
274 	ser_matched = 1;
275 	return 1;
276 }
277 
278 /*ARGSUSED*/
279 static void
280 serattach(struct device *pdp, struct device *dp, void *auxp)
281 {
282 	struct ser_softc *sc = device_private(dp);
283 
284 	if (intr_establish(1, USER_VEC, 0, (hw_ifun_t)sermintr, sc) == NULL)
285 		printf("serattach: Can't establish interrupt (1)\n");
286 	if (intr_establish(2, USER_VEC, 0, (hw_ifun_t)sermintr, sc) == NULL)
287 		printf("serattach: Can't establish interrupt (2)\n");
288 	if (intr_establish(14, USER_VEC, 0, (hw_ifun_t)sermintr, sc) == NULL)
289 		printf("serattach: Can't establish interrupt (14)\n");
290 	if (intr_establish(9, USER_VEC, 0, (hw_ifun_t)sertrintr, sc) == NULL)
291 		printf("serattach: Can't establish interrupt (9)\n");
292 	if (intr_establish(10, USER_VEC, 0, (hw_ifun_t)sertrintr, sc) == NULL)
293 		printf("serattach: Can't establish interrupt (10)\n");
294 	if (intr_establish(11, USER_VEC, 0, (hw_ifun_t)sertrintr, sc) == NULL)
295 		printf("serattach: Can't establish interrupt (11)\n");
296 	if (intr_establish(12, USER_VEC, 0, (hw_ifun_t)sertrintr, sc) == NULL)
297 		printf("serattach: Can't establish interrupt (12)\n");
298 
299 	sc->sc_sicookie = softint_establish(SOFTINT_SERIAL, sersoft, sc);
300 
301 	ym2149_rts(1);
302 	ym2149_dtr(1);
303 
304 	/*
305 	 * Enable but mask interrupts...
306 	 * XXX: Look at edge-sensitivity for DCD/CTS interrupts.
307 	 */
308 	MFP->mf_ierb |= IB_SCTS|IB_SDCD;
309 	MFP->mf_iera |= IA_RRDY|IA_RERR|IA_TRDY|IA_TERR;
310 	MFP->mf_imrb &= ~(IB_SCTS|IB_SDCD);
311 	MFP->mf_imra &= ~(IA_RRDY|IA_RERR|IA_TRDY|IA_TERR);
312 
313 	callout_init(&sc->sc_diag_ch, 0);
314 
315 #if SERCONSOLE > 0
316 	/*
317 	 * Activate serial console when DCD present...
318 	 */
319 	if (!(MFP->mf_gpip & MCR_DCD))
320 		SET(sc->sc_hwflags, SER_HW_CONSOLE);
321 #endif /* SERCONSOLE > 0 */
322 
323 	printf("\n");
324 	if (ISSET(sc->sc_hwflags, SER_HW_CONSOLE)) {
325 		serinit(CONSBAUD);
326 		printf("%s: console\n", sc->sc_dev.dv_xname);
327 	}
328 }
329 
330 #ifdef SER_DEBUG
331 void serstatus(struct ser_softc *, char *);
332 void
333 serstatus(struct ser_softc *sc, char *str)
334 {
335 	struct tty *tp = sc->sc_tty;
336 
337 	printf("%s: %s %sclocal  %sdcd %sts_carr_on %sdtr %stx_stopped\n",
338 	    sc->sc_dev.dv_xname, str,
339 	    ISSET(tp->t_cflag, CLOCAL) ? "+" : "-",
340 	    ISSET(sc->sc_msr, MCR_DCD) ? "+" : "-",
341 	    ISSET(tp->t_state, TS_CARR_ON) ? "+" : "-",
342 	    ISSET(sc->sc_mcr, MCR_DTR) ? "+" : "-",
343 	    sc->sc_tx_stopped ? "+" : "-");
344 
345 	printf("%s: %s %scrtscts %scts %sts_ttstop  %srts %srx_blocked\n",
346 	    sc->sc_dev.dv_xname, str,
347 	    ISSET(tp->t_cflag, CRTSCTS) ? "+" : "-",
348 	    ISSET(sc->sc_msr, MCR_CTS) ? "+" : "-",
349 	    ISSET(tp->t_state, TS_TTSTOP) ? "+" : "-",
350 	    ISSET(sc->sc_mcr, MCR_RTS) ? "+" : "-",
351 	    sc->sc_rx_blocked ? "+" : "-");
352 }
353 #endif /* SER_DEBUG */
354 
355 int
356 seropen(dev_t dev, int flag, int mode, struct lwp *l)
357 {
358 	int unit = SERUNIT(dev);
359 	struct ser_softc *sc;
360 	struct tty *tp;
361 	int s, s2;
362 	int error = 0;
363 
364 	sc = device_lookup_private(&ser_cd, unit);
365 	if (sc == NULL)
366 		return (ENXIO);
367 
368 	if (!sc->sc_tty) {
369 		tp = sc->sc_tty = ttymalloc();
370 		tty_attach(tp);
371 	} else
372 		tp = sc->sc_tty;
373 
374 	if (kauth_authorize_device_tty(l->l_cred, KAUTH_DEVICE_TTY_OPEN, tp))
375 		return (EBUSY);
376 
377 	s = spltty();
378 
379 	/*
380 	 * Do the following if this is a first open.
381 	 */
382 	if (!ISSET(tp->t_state, TS_ISOPEN) && tp->t_wopen == 0) {
383 	    struct termios t;
384 
385 	    /* Turn on interrupts. */
386 	    sc->sc_imra = IA_RRDY|IA_RERR|IA_TRDY|IA_TERR;
387 	    sc->sc_imrb = IB_SCTS|IB_SDCD;
388 	    single_inst_bset_b(MFP->mf_imra, sc->sc_imra);
389 	    single_inst_bset_b(MFP->mf_imrb, sc->sc_imrb);
390 
391 	    /* Fetch the current modem control status, needed later. */
392 	    sc->sc_msr = ~MFP->mf_gpip & (IO_SDCD|IO_SCTS|IO_SRI);
393 
394 	    /* Add some entry points needed by the tty layer. */
395 	    tp->t_oproc = serstart;
396 	    tp->t_param = serparam;
397 	    tp->t_hwiflow = serhwiflow;
398 	    tp->t_dev = dev;
399 
400 	    /*
401 	     * Initialize the termios status to the defaults.  Add in the
402 	     * sticky bits from TIOCSFLAGS.
403 	     */
404 	    t.c_ispeed = 0;
405 	    if (ISSET(sc->sc_hwflags, SER_HW_CONSOLE)) {
406 		    t.c_ospeed = CONSBAUD;
407 		    t.c_cflag  = CONSCFLAG;
408 	    }
409 	    else {
410 		    t.c_ospeed = TTYDEF_SPEED;
411 		    t.c_cflag = TTYDEF_CFLAG;
412 	    }
413 	    if (ISSET(sc->sc_swflags, TIOCFLAG_CLOCAL))
414 		    SET(t.c_cflag, CLOCAL);
415 	    if (ISSET(sc->sc_swflags, TIOCFLAG_CRTSCTS))
416 		    SET(t.c_cflag, CRTSCTS);
417 	    if (ISSET(sc->sc_swflags, TIOCFLAG_MDMBUF))
418 		    SET(t.c_cflag, MDMBUF);
419 	    tp->t_iflag = TTYDEF_IFLAG;
420 	    tp->t_oflag = TTYDEF_OFLAG;
421 	    tp->t_lflag = TTYDEF_LFLAG;
422 	    ttychars(tp);
423 	    (void) serparam(tp, &t);
424 	    ttsetwater(tp);
425 
426 	    s2 = splhigh();
427 
428 	    /*
429 	     * Turn on DTR.  We must always do this, even if carrier is not
430 	     * present, because otherwise we'd have to use TIOCSDTR
431 	     * immediately after setting CLOCAL.  We will drop DTR only on
432 	     * the next high-low transition of DCD, or by explicit request.
433 	     */
434 	    ser_modem(sc, 1);
435 
436 	    /* Clear the input ring, and unblock. */
437 	    sc->sc_rbput = sc->sc_rbget = 0;
438 	    sc->sc_rbavail = RXBUFSIZE;
439 	    ser_iflush(sc);
440 	    sc->sc_rx_blocked = 0;
441 	    ser_hwiflow(sc, 0);
442 
443 #ifdef SER_DEBUG
444 	    serstatus(sc, "seropen  ");
445 #endif
446 
447 	    splx(s2);
448 	}
449 
450 	splx(s);
451 
452 	error = ttyopen(tp, SERDIALOUT(dev), ISSET(flag, O_NONBLOCK));
453 	if (error)
454 		goto bad;
455 
456 	error = (*tp->t_linesw->l_open)(dev, tp);
457         if (error)
458 		goto bad;
459 
460 	return (0);
461 
462 bad:
463 	if (!ISSET(tp->t_state, TS_ISOPEN) && tp->t_wopen == 0) {
464 		/*
465 		 * We failed to open the device, and nobody else had it opened.
466 		 * Clean up the state as appropriate.
467 		 */
468 		ser_shutdown(sc);
469 	}
470 
471 	return (error);
472 }
473 
474 int
475 serclose(dev_t dev, int flag, int mode, struct lwp *l)
476 {
477 	int unit = SERUNIT(dev);
478 	struct ser_softc *sc = device_lookup_private(&ser_cd, unit);
479 	struct tty *tp = sc->sc_tty;
480 
481 	/* XXX This is for cons.c. */
482 	if (!ISSET(tp->t_state, TS_ISOPEN))
483 		return (0);
484 
485 	(*tp->t_linesw->l_close)(tp, flag);
486 	ttyclose(tp);
487 
488 	if (!ISSET(tp->t_state, TS_ISOPEN) && tp->t_wopen == 0) {
489 		/*
490 		 * Although we got a last close, the device may still be in
491 		 * use; e.g. if this was the dialout node, and there are still
492 		 * processes waiting for carrier on the non-dialout node.
493 		 */
494 		ser_shutdown(sc);
495 	}
496 
497 	return (0);
498 }
499 
500 int
501 serread(dev_t dev, struct uio *uio, int flag)
502 {
503 	struct ser_softc *sc = device_lookup_private(&ser_cd, SERUNIT(dev));
504 	struct tty *tp = sc->sc_tty;
505 
506 	return ((*tp->t_linesw->l_read)(tp, uio, flag));
507 }
508 
509 int
510 serwrite(dev_t dev, struct uio *uio, int flag)
511 {
512 	struct ser_softc *sc = device_lookup_private(&ser_cd, SERUNIT(dev));
513 	struct tty *tp = sc->sc_tty;
514 
515 	return ((*tp->t_linesw->l_write)(tp, uio, flag));
516 }
517 
518 int
519 serpoll(dev_t dev, int events, struct lwp *l)
520 {
521 	struct ser_softc *sc = device_lookup_private(&ser_cd, SERUNIT(dev));
522 	struct tty *tp = sc->sc_tty;
523 
524 	return ((*tp->t_linesw->l_poll)(tp, events, l));
525 }
526 
527 struct tty *
528 sertty(dev_t dev)
529 {
530 	struct ser_softc *sc = device_lookup_private(&ser_cd, SERUNIT(dev));
531 	struct tty *tp = sc->sc_tty;
532 
533 	return (tp);
534 }
535 
536 int
537 serioctl(dev_t dev, u_long cmd, void *data, int flag, struct lwp *l)
538 {
539 	int unit = SERUNIT(dev);
540 	struct ser_softc *sc = device_lookup_private(&ser_cd, unit);
541 	struct tty *tp = sc->sc_tty;
542 	int error;
543 
544 	error = (*tp->t_linesw->l_ioctl)(tp, cmd, data, flag, l);
545 	if (error != EPASSTHROUGH)
546 		return (error);
547 
548 	error = ttioctl(tp, cmd, data, flag, l);
549 	if (error != EPASSTHROUGH)
550 		return (error);
551 
552 	switch (cmd) {
553 	case TIOCSBRK:
554 		ser_break(sc, 1);
555 		break;
556 
557 	case TIOCCBRK:
558 		ser_break(sc, 0);
559 		break;
560 
561 	case TIOCSDTR:
562 		ser_modem(sc, 1);
563 		break;
564 
565 	case TIOCCDTR:
566 		ser_modem(sc, 0);
567 		break;
568 
569 	case TIOCGFLAGS:
570 		*(int *)data = sc->sc_swflags;
571 		break;
572 
573 	case TIOCSFLAGS:
574 		error = kauth_authorize_device_tty(l->l_cred,
575 		    KAUTH_DEVICE_TTY_PRIVSET, tp);
576 		if (error)
577 			return (error);
578 		sc->sc_swflags = *(int *)data;
579 		break;
580 
581 	case TIOCMSET:
582 	case TIOCMBIS:
583 	case TIOCMBIC:
584 	case TIOCMGET:
585 	default:
586 		return (EPASSTHROUGH);
587 	}
588 
589 #ifdef SER_DEBUG
590 		serstatus(sc, "serioctl ");
591 #endif
592 
593 	return (0);
594 }
595 
596 void
597 ser_break(struct ser_softc *sc, int onoff)
598 {
599 	int s;
600 
601 	s = splhigh();
602 	if (onoff)
603 		SET(sc->sc_tsr, TSR_SBREAK);
604 	else
605 		CLR(sc->sc_tsr, TSR_SBREAK);
606 
607 	if (!sc->sc_heldchange) {
608 		if (sc->sc_tx_busy) {
609 			sc->sc_heldtbc = sc->sc_tbc;
610 			sc->sc_tbc = 0;
611 			sc->sc_heldchange = 1;
612 		} else
613 			ser_loadchannelregs(sc);
614 	}
615 	splx(s);
616 }
617 
618 void
619 ser_modem(struct ser_softc *sc, int onoff)
620 {
621 	int s;
622 
623 	s = splhigh();
624 	if (onoff)
625 		SET(sc->sc_mcr, sc->sc_mcr_dtr);
626 	else
627 		CLR(sc->sc_mcr, sc->sc_mcr_dtr);
628 
629 	if (!sc->sc_heldchange) {
630 		if (sc->sc_tx_busy) {
631 			sc->sc_heldtbc = sc->sc_tbc;
632 			sc->sc_tbc = 0;
633 			sc->sc_heldchange = 1;
634 		} else
635 			ser_loadchannelregs(sc);
636 	}
637 	splx(s);
638 }
639 
640 int
641 serparam(struct tty *tp, struct termios *t)
642 {
643 	struct ser_softc *sc =
644 	    device_lookup_private(&ser_cd, SERUNIT(tp->t_dev));
645 	int ospeed = serspeed(t->c_ospeed);
646 	u_char ucr;
647 	int s;
648 
649 
650 	/* check requested parameters */
651 	if (ospeed < 0)
652 		return (EINVAL);
653 	if (t->c_ispeed && t->c_ispeed != t->c_ospeed)
654 		return (EINVAL);
655 
656 	sc->sc_rsr = RSR_ENAB;
657 	sc->sc_tsr = TSR_ENAB;
658 
659 	ucr = UCR_CLKDIV;
660 
661 	switch (ISSET(t->c_cflag, CSIZE)) {
662 	case CS5:
663 		SET(ucr, UCR_5BITS);
664 		break;
665 	case CS6:
666 		SET(ucr, UCR_6BITS);
667 		break;
668 	case CS7:
669 		SET(ucr, UCR_7BITS);
670 		break;
671 	case CS8:
672 		SET(ucr, UCR_8BITS);
673 		break;
674 	}
675 	if (ISSET(t->c_cflag, PARENB)) {
676 		SET(ucr, UCR_PENAB);
677 		if (!ISSET(t->c_cflag, PARODD))
678 			SET(ucr, UCR_PEVEN);
679 	}
680 	if (ISSET(t->c_cflag, CSTOPB))
681 		SET(ucr, UCR_STOPB2);
682 	else
683 		SET(ucr, UCR_STOPB1);
684 
685 	s = splhigh();
686 
687 	sc->sc_ucr = ucr;
688 
689 	/*
690 	 * For the console, always force CLOCAL and !HUPCL, so that the port
691 	 * is always active.
692 	 */
693 	if (ISSET(sc->sc_swflags, TIOCFLAG_SOFTCAR) ||
694 	    ISSET(sc->sc_hwflags, SER_HW_CONSOLE)) {
695 		SET(t->c_cflag, CLOCAL);
696 		CLR(t->c_cflag, HUPCL);
697 	}
698 
699 	/*
700 	 * If we're not in a mode that assumes a connection is present, then
701 	 * ignore carrier changes.
702 	 */
703 	if (ISSET(t->c_cflag, CLOCAL | MDMBUF))
704 		sc->sc_msr_dcd = 0;
705 	else
706 		sc->sc_msr_dcd = MCR_DCD;
707 	/*
708 	 * Set the flow control pins depending on the current flow control
709 	 * mode.
710 	 */
711 	if (ISSET(t->c_cflag, CRTSCTS)) {
712 		sc->sc_mcr_dtr = MCR_DTR;
713 		sc->sc_mcr_rts = MCR_RTS;
714 		sc->sc_msr_cts = MCR_CTS;
715 		sc->sc_r_hiwat = RXHIWAT;
716 	} else if (ISSET(t->c_cflag, MDMBUF)) {
717 		/*
718 		 * For DTR/DCD flow control, make sure we don't toggle DTR for
719 		 * carrier detection.
720 		 */
721 		sc->sc_mcr_dtr = 0;
722 		sc->sc_mcr_rts = MCR_DTR;
723 		sc->sc_msr_cts = MCR_DCD;
724 		sc->sc_r_hiwat = RXHIWAT;
725 	} else {
726 		/*
727 		 * If no flow control, then always set RTS.  This will make
728 		 * the other side happy if it mistakenly thinks we're doing
729 		 * RTS/CTS flow control.
730 		 */
731 		sc->sc_mcr_dtr = MCR_DTR | MCR_RTS;
732 		sc->sc_mcr_rts = 0;
733 		sc->sc_msr_cts = 0;
734 		sc->sc_r_hiwat = 0;
735 		if (ISSET(sc->sc_mcr, MCR_DTR))
736 			SET(sc->sc_mcr, MCR_RTS);
737 		else
738 			CLR(sc->sc_mcr, MCR_RTS);
739 	}
740 	sc->sc_msr_mask = sc->sc_msr_cts | sc->sc_msr_dcd;
741 
742 #if 0
743 	if (ospeed == 0)
744 		CLR(sc->sc_mcr, sc->sc_mcr_dtr);
745 	else
746 		SET(sc->sc_mcr, sc->sc_mcr_dtr);
747 #endif
748 
749 	sc->sc_ospeed = ospeed;
750 
751 	/* and copy to tty */
752 	tp->t_ispeed = 0;
753 	tp->t_ospeed = t->c_ospeed;
754 	tp->t_cflag = t->c_cflag;
755 
756 	if (!sc->sc_heldchange) {
757 		if (sc->sc_tx_busy) {
758 			sc->sc_heldtbc = sc->sc_tbc;
759 			sc->sc_tbc = 0;
760 			sc->sc_heldchange = 1;
761 		} else
762 			ser_loadchannelregs(sc);
763 	}
764 
765 	splx(s);
766 
767 	/*
768 	 * Update the tty layer's idea of the carrier bit, in case we changed
769 	 * CLOCAL or MDMBUF.  We don't hang up here; we only do that if we
770 	 * lose carrier while carrier detection is on.
771 	 */
772 	(void) (*tp->t_linesw->l_modem)(tp, ISSET(sc->sc_msr, MCR_DCD));
773 
774 #ifdef SER_DEBUG
775 	serstatus(sc, "serparam ");
776 #endif
777 
778 	/* XXXXX FIX ME */
779 	/* Block or unblock as needed. */
780 	if (!ISSET(t->c_cflag, CHWFLOW)) {
781 		if (sc->sc_rx_blocked) {
782 			sc->sc_rx_blocked = 0;
783 			ser_hwiflow(sc, 0);
784 		}
785 		if (sc->sc_tx_stopped) {
786 			sc->sc_tx_stopped = 0;
787 			serstart(tp);
788 		}
789 	} else {
790 #if 0
791 		sermsrint(sc, tp);
792 #endif
793 	}
794 
795 	return (0);
796 }
797 
798 void
799 ser_iflush(struct ser_softc *sc)
800 {
801 	u_char	tmp;
802 
803 	/* flush any pending I/O */
804 	while (ISSET(MFP->mf_rsr, RSR_CIP|RSR_BFULL))
805 		tmp = MFP->mf_udr;
806 }
807 
808 void
809 ser_loadchannelregs(struct ser_softc *sc)
810 {
811 	/* XXXXX necessary? */
812 	ser_iflush(sc);
813 
814 	/*
815 	 * No interrupts please...
816 	 */
817 if((MFP->mf_imra & (IA_RRDY|IA_RERR|IA_TRDY|IA_TERR)) != sc->sc_imra) {
818 printf("loadchannelregs: mf_imra: %x sc_imra: %x\n", (u_int)MFP->mf_imra,
819 						     (u_int)sc->sc_imra);
820 }
821 if((MFP->mf_imrb & (IB_SCTS|IB_SDCD)) != sc->sc_imrb) {
822 printf("loadchannelregs: mf_imrb: %x sc_imrb: %x\n", (u_int)MFP->mf_imrb,
823 						     (u_int)sc->sc_imrb);
824 }
825 	single_inst_bclr_b(MFP->mf_imra, IA_RRDY|IA_RERR|IA_TRDY|IA_TERR);
826 	single_inst_bclr_b(MFP->mf_imrb, IB_SCTS|IB_SDCD);
827 
828 	MFP->mf_ucr = sc->sc_ucr;
829 	MFP->mf_rsr = sc->sc_rsr;
830 	MFP->mf_tsr = sc->sc_tsr;
831 
832 	single_inst_bclr_b(MFP->mf_tcdcr, 0x07);
833 	MFP->mf_tddr  = sc->sc_ospeed;
834 	single_inst_bset_b(MFP->mf_tcdcr, (sc->sc_ospeed >> 8) & 0x0f);
835 
836 	sc->sc_mcr_active = sc->sc_mcr;
837 
838 	if (machineid & ATARI_HADES) {
839 		/* PCB fault, wires exchanged..... */
840 		ym2149_rts(!(sc->sc_mcr_active & MCR_DTR));
841 		ym2149_dtr(!(sc->sc_mcr_active & MCR_RTS));
842 	}
843 	else {
844 		ym2149_rts(!(sc->sc_mcr_active & MCR_RTS));
845 		ym2149_dtr(!(sc->sc_mcr_active & MCR_DTR));
846 	}
847 
848 	single_inst_bset_b(MFP->mf_imra, sc->sc_imra);
849 	single_inst_bset_b(MFP->mf_imrb, sc->sc_imrb);
850 }
851 
852 int
853 serhwiflow(struct tty *tp, int block)
854 {
855 	struct ser_softc *sc =
856 	    device_lookup_private(&ser_cd, SERUNIT(tp->t_dev));
857 	int s;
858 
859 	if (sc->sc_mcr_rts == 0)
860 		return (0);
861 
862 	s = splhigh();
863 	if (block) {
864 		/*
865 		 * The tty layer is asking us to block input.
866 		 * If we already did it, just return TRUE.
867 		 */
868 		if (sc->sc_rx_blocked)
869 			goto out;
870 		sc->sc_rx_blocked = 1;
871 	} else {
872 		/*
873 		 * The tty layer is asking us to resume input.
874 		 * The input ring is always empty by now.
875 		 */
876 		sc->sc_rx_blocked = 0;
877 	}
878 	ser_hwiflow(sc, block);
879 out:
880 	splx(s);
881 	return (1);
882 }
883 
884 /*
885  * (un)block input via hw flowcontrol
886  */
887 void
888 ser_hwiflow(struct ser_softc *sc, int block)
889 {
890 	if (sc->sc_mcr_rts == 0)
891 		return;
892 
893 	if (block) {
894 		CLR(sc->sc_mcr, sc->sc_mcr_rts);
895 		CLR(sc->sc_mcr_active, sc->sc_mcr_rts);
896 	} else {
897 		SET(sc->sc_mcr, sc->sc_mcr_rts);
898 		SET(sc->sc_mcr_active, sc->sc_mcr_rts);
899 	}
900 	if (machineid & ATARI_HADES) {
901 		/* PCB fault, wires exchanged..... */
902 		ym2149_dtr(sc->sc_mcr_active & MCR_RTS);
903 	}
904 	else {
905 		ym2149_rts(sc->sc_mcr_active & MCR_RTS);
906 	}
907 }
908 
909 void
910 serstart(struct tty *tp)
911 {
912 	struct ser_softc *sc =
913 	    device_lookup_private(&ser_cd, SERUNIT(tp->t_dev));
914 	int s;
915 
916 	s = spltty();
917 	if (ISSET(tp->t_state, TS_BUSY))
918 		goto out;
919 	if (ISSET(tp->t_state, TS_TIMEOUT | TS_TTSTOP))
920 		goto stopped;
921 
922 	if (sc->sc_tx_stopped)
923 		goto stopped;
924 	if (!ttypull(tp))
925 		goto stopped;
926 
927 	/* Grab the first contiguous region of buffer space. */
928 	{
929 		u_char *tba;
930 		int tbc;
931 
932 		tba = tp->t_outq.c_cf;
933 		tbc = ndqb(&tp->t_outq, 0);
934 
935 		(void)splhigh();
936 
937 		sc->sc_tba = tba;
938 		sc->sc_tbc = tbc;
939 	}
940 
941 	SET(tp->t_state, TS_BUSY);
942 	sc->sc_tx_busy = 1;
943 
944 	/* Enable transmit completion interrupts if necessary. */
945 	if (!ISSET(sc->sc_imra, IA_TRDY)) {
946 		SET(sc->sc_imra, IA_TRDY|IA_TERR);
947 		single_inst_bset_b(MFP->mf_imra, IA_TRDY|IA_TERR);
948 	}
949 
950 	/* Output the first char */
951 	MFP->mf_udr = *sc->sc_tba;
952 	sc->sc_tbc--;
953 	sc->sc_tba++;
954 
955 	splx(s);
956 	return;
957 
958 stopped:
959 	/* Disable transmit completion interrupts if necessary. */
960 	if (ISSET(sc->sc_imra, IA_TRDY)) {
961 		CLR(sc->sc_imra, IA_TRDY|IA_TERR);
962 		single_inst_bclr_b(MFP->mf_imra, IA_TRDY|IA_TERR);
963 	}
964 out:
965 	splx(s);
966 	return;
967 }
968 
969 /*
970  * Stop output on a line.
971  */
972 void
973 serstop(struct tty *tp, int flag)
974 {
975 	struct ser_softc *sc =
976 	    device_lookup_private(&ser_cd, SERUNIT(tp->t_dev));
977 	int s;
978 
979 	s = splhigh();
980 	if (ISSET(tp->t_state, TS_BUSY)) {
981 		/* Stop transmitting at the next chunk. */
982 		sc->sc_tbc = 0;
983 		sc->sc_heldtbc = 0;
984 		if (!ISSET(tp->t_state, TS_TTSTOP))
985 			SET(tp->t_state, TS_FLUSH);
986 	}
987 	splx(s);
988 }
989 
990 void
991 serdiag(void *arg)
992 {
993 	struct ser_softc *sc = arg;
994 	int overflows, floods;
995 	int s;
996 
997 	s = splhigh();
998 	overflows = sc->sc_overflows;
999 	sc->sc_overflows = 0;
1000 	floods = sc->sc_floods;
1001 	sc->sc_floods = 0;
1002 	sc->sc_errors = 0;
1003 	splx(s);
1004 
1005 	log(LOG_WARNING,
1006 	    "%s: %d silo overflow%s, %d ibuf flood%s\n",
1007 	    sc->sc_dev.dv_xname,
1008 	    overflows, overflows == 1 ? "" : "s",
1009 	    floods, floods == 1 ? "" : "s");
1010 }
1011 
1012 static
1013 void ser_shutdown(sc)
1014 	struct ser_softc *sc;
1015 {
1016 	int	s;
1017 	struct tty *tp = sc->sc_tty;
1018 
1019 
1020 	s = splhigh();
1021 
1022 	/* If we were asserting flow control, then deassert it. */
1023 	sc->sc_rx_blocked = 1;
1024 	ser_hwiflow(sc, 1);
1025 
1026 	/* Clear any break condition set with TIOCSBRK. */
1027 	ser_break(sc, 0);
1028 
1029 	/*
1030 	 * Hang up if necessary.  Wait a bit, so the other side has time to
1031 	 * notice even if we immediately open the port again.
1032 	 */
1033 	if (ISSET(tp->t_cflag, HUPCL)) {
1034 		ser_modem(sc, 0);
1035 		(void) tsleep(sc, TTIPRI, ttclos, hz);
1036 	}
1037 
1038 	/* Turn off interrupts. */
1039 	CLR(sc->sc_imra, IA_RRDY|IA_RERR|IA_TRDY|IA_TERR);
1040 	CLR(sc->sc_imrb, IB_SCTS|IB_SDCD);
1041 	single_inst_bclr_b(MFP->mf_imrb, IB_SCTS|IB_SDCD);
1042 	single_inst_bclr_b(MFP->mf_imra, IA_RRDY|IA_RERR|IA_TRDY|IA_TERR);
1043 	splx(s);
1044 }
1045 
1046 static void
1047 serrxint(struct ser_softc *sc, struct tty *tp)
1048 {
1049 	u_int	get, cc, scc;
1050 	int	code;
1051 	u_char	rsr;
1052 	int	s;
1053 	static int lsrmap[8] = {
1054 		0,      TTY_PE,
1055 		TTY_FE, TTY_PE|TTY_FE,
1056 		TTY_FE, TTY_PE|TTY_FE,
1057 		TTY_FE, TTY_PE|TTY_FE
1058 	};
1059 
1060 	get = sc->sc_rbget;
1061 	scc = cc = RXBUFSIZE - sc->sc_rbavail;
1062 
1063 	if (cc == RXBUFSIZE) {
1064 		sc->sc_floods++;
1065 		if (sc->sc_errors++ == 0)
1066 			callout_reset(&sc->sc_diag_ch, 60 * hz, serdiag, sc);
1067 	}
1068 
1069 	while (cc--) {
1070 		rsr = sc->sc_lbuf[get];
1071 		if (ISSET(rsr, RSR_BREAK)) {
1072 #ifdef DDB
1073 			if (ISSET(sc->sc_hwflags, SER_HW_CONSOLE))
1074 				Debugger();
1075 #endif
1076 		}
1077 		else if (ISSET(rsr, RSR_OERR)) {
1078 			sc->sc_overflows++;
1079 			if (sc->sc_errors++ == 0)
1080 				callout_reset(&sc->sc_diag_ch, 60 * hz,
1081 				    serdiag, sc);
1082 		}
1083 		code = sc->sc_rbuf[get] |
1084 		    lsrmap[(rsr & (RSR_BREAK|RSR_FERR|RSR_PERR)) >> 3];
1085 		(*tp->t_linesw->l_rint)(code, tp);
1086 		get = (get + 1) & RXBUFMASK;
1087 	}
1088 
1089 	sc->sc_rbget = get;
1090 	s = splhigh();
1091 	sc->sc_rbavail += scc;
1092 	/*
1093 	 * Buffers should be ok again, release possible block, but only if the
1094 	 * tty layer isn't blocking too.
1095 	 */
1096 	if (sc->sc_rx_blocked && !ISSET(tp->t_state, TS_TBLOCK)) {
1097 		sc->sc_rx_blocked = 0;
1098 		ser_hwiflow(sc, 0);
1099 	}
1100 	splx(s);
1101 }
1102 
1103 static void
1104 sertxint(struct ser_softc *sc, struct tty *tp)
1105 {
1106 
1107 	CLR(tp->t_state, TS_BUSY);
1108 	if (ISSET(tp->t_state, TS_FLUSH))
1109 		CLR(tp->t_state, TS_FLUSH);
1110 	else
1111 		ndflush(&tp->t_outq, (int)(sc->sc_tba - tp->t_outq.c_cf));
1112 	(*tp->t_linesw->l_start)(tp);
1113 }
1114 
1115 static void
1116 sermsrint(struct ser_softc *sc, struct tty *tp)
1117 {
1118 	u_char msr, delta;
1119 	int s;
1120 
1121 	s = splhigh();
1122 	msr = sc->sc_msr;
1123 	delta = sc->sc_msr_delta;
1124 	sc->sc_msr_delta = 0;
1125 	splx(s);
1126 
1127 	if (ISSET(delta, sc->sc_msr_dcd)) {
1128 		/*
1129 		 * Inform the tty layer that carrier detect changed.
1130 		 */
1131 		(void) (*tp->t_linesw->l_modem)(tp, ISSET(msr, MCR_DCD));
1132 	}
1133 
1134 	if (ISSET(delta, sc->sc_msr_cts)) {
1135 		/* Block or unblock output according to flow control. */
1136 		if (ISSET(msr, sc->sc_msr_cts)) {
1137 			sc->sc_tx_stopped = 0;
1138 			(*tp->t_linesw->l_start)(tp);
1139 		} else {
1140 			sc->sc_tx_stopped = 1;
1141 			serstop(tp, 0);
1142 		}
1143 	}
1144 
1145 #ifdef SER_DEBUG
1146 	serstatus(sc, "sermsrint");
1147 #endif
1148 }
1149 
1150 void
1151 sersoft(void *arg)
1152 {
1153 	struct ser_softc *sc = arg;
1154 	struct tty	*tp;
1155 
1156 	tp = sc->sc_tty;
1157 	if (tp == NULL)
1158 		return;
1159 
1160 	if (!ISSET(tp->t_state, TS_ISOPEN) && (tp->t_wopen == 0))
1161 		return;
1162 
1163 	if (sc->sc_rx_ready) {
1164 		sc->sc_rx_ready = 0;
1165 		serrxint(sc, tp);
1166 	}
1167 
1168 	if (sc->sc_st_check) {
1169 		sc->sc_st_check = 0;
1170 		sermsrint(sc, tp);
1171 	}
1172 
1173 	if (sc->sc_tx_done) {
1174 		sc->sc_tx_done = 0;
1175 		sertxint(sc, tp);
1176 	}
1177 }
1178 
1179 int
1180 sermintr(void *arg)
1181 {
1182 	struct ser_softc *sc = arg;
1183 	u_char	msr, delta;
1184 
1185 	msr = ~MFP->mf_gpip;
1186 	delta = msr ^ sc->sc_msr;
1187 	sc->sc_msr  = sc->sc_msr & ~(MCR_CTS|MCR_DCD|MCR_RI);
1188 	sc->sc_msr |= msr & (MCR_CTS|MCR_DCD|MCR_RI);
1189 
1190 	if (ISSET(delta, sc->sc_msr_mask)) {
1191 		sc->sc_msr_delta |= delta;
1192 
1193 		/*
1194 		 * Stop output immediately if we lose the output
1195 		 * flow control signal or carrier detect.
1196 		 */
1197 		if (ISSET(~msr, sc->sc_msr_mask)) {
1198 			sc->sc_tbc = 0;
1199 			sc->sc_heldtbc = 0;
1200 #ifdef SER_DEBUG
1201 			serstatus(sc, "sermintr  ");
1202 #endif
1203 		}
1204 
1205 		sc->sc_st_check = 1;
1206 	}
1207 	softint_schedule(sc->sc_sicookie);
1208 	return 1;
1209 }
1210 
1211 int
1212 sertrintr(void *arg)
1213 {
1214 	struct ser_softc *sc = arg;
1215 	u_int	put, cc;
1216 	u_char	rsr, tsr;
1217 
1218 	put = sc->sc_rbput;
1219 	cc = sc->sc_rbavail;
1220 
1221 	rsr = MFP->mf_rsr;
1222 	if (ISSET(rsr, RSR_BFULL|RSR_BREAK)) {
1223 		for (; ISSET(rsr, RSR_BFULL|RSR_BREAK) && cc > 0; cc--) {
1224 			sc->sc_rbuf[put] = MFP->mf_udr;
1225 			sc->sc_lbuf[put] = rsr;
1226 			put = (put + 1) & RXBUFMASK;
1227 			if ((rsr & RSR_BREAK) && (MFP->mf_rsr & RSR_BREAK))
1228 				rsr = 0;
1229 			else rsr = MFP->mf_rsr;
1230 		}
1231 		/*
1232 		 * Current string of incoming characters ended because
1233 		 * no more data was available. Schedule a receive event
1234 		 * if any data was received. Drop any characters that
1235 		 * we couldn't handle.
1236 		 */
1237 		sc->sc_rbput    = put;
1238 		sc->sc_rbavail  = cc;
1239 		sc->sc_rx_ready = 1;
1240 		/*
1241 		 * See if we are in danger of overflowing a buffer. If
1242 		 * so, use hardware flow control to ease the pressure.
1243 		 */
1244 		if (sc->sc_rx_blocked == 0 &&
1245 		    cc < sc->sc_r_hiwat) {
1246 			sc->sc_rx_blocked = 1;
1247 			ser_hwiflow(sc, 1);
1248 		}
1249 		/*
1250 		 * If we're out of space, throw away any further input.
1251 		 */
1252 		if (!cc) {
1253 			while (ISSET(rsr, RSR_BFULL|RSR_BREAK)) {
1254 				rsr = MFP->mf_udr;
1255 				rsr = MFP->mf_rsr;
1256 			}
1257 		}
1258 	}
1259 
1260 	/*
1261 	 * Done handling any receive interrupts. See if data can be
1262 	 * transmitted as well. Schedule tx done event if no data left
1263 	 * and tty was marked busy.
1264 	 */
1265 	tsr = MFP->mf_tsr;
1266 	if (ISSET(tsr, TSR_BE)) {
1267 		/*
1268 		 * If we've delayed a parameter change, do it now, and restart
1269 		 * output.
1270 		 */
1271 		if (sc->sc_heldchange) {
1272 			ser_loadchannelregs(sc);
1273 			sc->sc_heldchange = 0;
1274 			sc->sc_tbc = sc->sc_heldtbc;
1275 			sc->sc_heldtbc = 0;
1276 		}
1277 		/* Output the next character, if any. */
1278 		if (sc->sc_tbc > 0) {
1279 			MFP->mf_udr = *sc->sc_tba;
1280 			sc->sc_tbc--;
1281 			sc->sc_tba++;
1282 		} else if (sc->sc_tx_busy) {
1283 			sc->sc_tx_busy = 0;
1284 			sc->sc_tx_done = 1;
1285 		}
1286 	}
1287 	softint_schedule(sc->sc_sicookie);
1288 	return 1;
1289 }
1290 
1291 static int
1292 serspeed(long speed)
1293 {
1294 #define	divrnd(n, q)	(((n)*2/(q)+1)/2)	/* divide and round off */
1295 
1296 	int div, x, err;
1297 
1298 	if (speed <= 0)
1299 		return (-1);
1300 
1301 	for (div = 4; div <= 64; div *= 4) {
1302 		x = divrnd((SER_FREQ / div), speed);
1303 
1304 		/*
1305 		 * The value must fit in the timer-d dataregister. If
1306 		 * not, try another delay-mode.
1307 		 */
1308 		if ((x/2) > 255)
1309 			continue;
1310 
1311 		/*
1312 		 * Baudrate to high for the interface or cannot be made
1313 		 * within tolerance.
1314 		 */
1315 		if (x <= 0)
1316 			return (-1);
1317 
1318 		err = divrnd((SER_FREQ / div) * 1000, speed * x) - 1000;
1319 		if (err < 0)
1320 			err = -err;
1321 		if (err > SER_TOLERANCE)
1322 			continue;
1323 
1324 		/*
1325 		 * Translate 'div' to delay-code
1326 		 */
1327 		if (div == 4)
1328 			div = 1;
1329 		else if (div == 16)
1330 			div = 3;
1331 		else if (div == 64)
1332 			div = 5;
1333 
1334 		return ((x/2) | (div << 8));
1335 	}
1336 	return (-1);
1337 
1338 #undef	divrnd
1339 }
1340 
1341 /*
1342  * Following are all routines needed for SER to act as console
1343  */
1344 #include <dev/cons.h>
1345 
1346 void
1347 sercnprobe(struct consdev *cp)
1348 {
1349 	/*
1350 	 * Activate serial console when DCD present...
1351 	 */
1352 	if (MFP->mf_gpip & MCR_DCD) {
1353 		cp->cn_pri = CN_DEAD;
1354 		return;
1355 	}
1356 
1357 	/* initialize required fields */
1358 	/* XXX: LWP What unit? */
1359 	cp->cn_dev = makedev(cdevsw_lookup_major(&ser_cdevsw), 0);
1360 #if SERCONSOLE > 0
1361 	cp->cn_pri = CN_REMOTE;	/* Force a serial port console */
1362 #else
1363 	cp->cn_pri = CN_NORMAL;
1364 #endif /* SERCONSOLE > 0 */
1365 }
1366 
1367 void
1368 sercninit(struct consdev *cp)
1369 {
1370 	serinitcons(CONSBAUD);
1371 }
1372 
1373 /*
1374  * Initialize UART to known state.
1375  */
1376 void
1377 serinit(int baud)
1378 {
1379 	int ospeed = serspeed(baud);
1380 
1381 	MFP->mf_ucr = UCR_CLKDIV|UCR_8BITS|UCR_STOPB1;
1382 	MFP->mf_rsr = RSR_ENAB;
1383 	MFP->mf_tsr = TSR_ENAB;
1384 
1385 	single_inst_bclr_b(MFP->mf_tcdcr, 0x07);
1386 	MFP->mf_tddr  = ospeed;
1387 	single_inst_bset_b(MFP->mf_tcdcr, (ospeed >> 8) & 0x0f);
1388 }
1389 
1390 /*
1391  * Set UART for console use. Do normal init, then enable interrupts.
1392  */
1393 void
1394 serinitcons(int baud)
1395 {
1396 	serinit(baud);
1397 
1398 	/* Set rts/dtr */
1399 	ym2149_rts(0);
1400 	ym2149_dtr(0);
1401 
1402 	single_inst_bset_b(MFP->mf_imra, (IA_RRDY|IA_RERR|IA_TRDY|IA_TERR));
1403 }
1404 
1405 int
1406 sercngetc(dev_t dev)
1407 {
1408 	u_char	stat, c;
1409 	int	s;
1410 
1411 	s = splhigh();
1412 	while (!ISSET(stat = MFP->mf_rsr, RSR_BFULL)) {
1413 		if (!ISSET(stat, RSR_ENAB)) /* XXX */
1414 			MFP->mf_rsr |= RSR_ENAB;
1415 		if (stat & (RSR_FERR|RSR_PERR|RSR_OERR))
1416 			c = MFP->mf_udr;
1417 	}
1418 	c = MFP->mf_udr;
1419 	splx(s);
1420 	return c;
1421 }
1422 
1423 u_int s_imra;
1424 u_int s_stat1, s_stat2, s_stat3;
1425 void
1426 sercnputc(dev_t dev, int c)
1427 {
1428 	int	timo;
1429 	u_char	stat, imra;
1430 
1431 	/* Mask serial interrupts */
1432 	imra  = MFP->mf_imra & (IA_RRDY|IA_RERR|IA_TRDY|IA_TERR);
1433 	single_inst_bclr_b(MFP->mf_imra, imra);
1434 s_imra = imra;
1435 
1436 	/* wait for any pending transmission to finish */
1437 	timo = 50000;
1438 s_stat1 = MFP->mf_tsr;
1439 	while (!ISSET(stat = MFP->mf_tsr, TSR_BE) && --timo)
1440 		;
1441 	MFP->mf_udr = c;
1442 	/* wait for this transmission to complete */
1443 	timo = 1500000;
1444 s_stat2 = MFP->mf_tsr;
1445 	while (!ISSET(stat = MFP->mf_tsr, TSR_BE) && --timo)
1446 		;
1447 
1448 s_stat3 = MFP->mf_tsr;
1449 	/* Clear pending serial interrupts and re-enable */
1450 	MFP->mf_ipra = (u_int8_t)~imra;
1451 	single_inst_bset_b(MFP->mf_imra, imra);
1452 }
1453 
1454 void
1455 sercnpollc(dev_t dev, int on)
1456 {
1457 
1458 }
1459