![[BACK]](/icons/back.gif){kind=icon}
Return to dca.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / hp300 / dev|
Return to dca.c CVS log | Up to [local] / sys / arch / hp300 / dev |
1.1 nbrk 1: /* $OpenBSD: dca.c,v 1.31 2006/01/01 11:59:37 miod Exp $ */
2: /* $NetBSD: dca.c,v 1.35 1997/05/05 20:58:18 thorpej Exp $ */
3:
4: /*
5: * Copyright (c) 1995, 1996, 1997 Jason R. Thorpe. All rights reserved.
6: * Copyright (c) 1982, 1986, 1990, 1993
7: * The Regents of the University of California. All rights reserved.
8: *
9: * Redistribution and use in source and binary forms, with or without
10: * modification, are permitted provided that the following conditions
11: * are met:
12: * 1. Redistributions of source code must retain the above copyright
13: * notice, this list of conditions and the following disclaimer.
14: * 2. Redistributions in binary form must reproduce the above copyright
15: * notice, this list of conditions and the following disclaimer in the
16: * documentation and/or other materials provided with the distribution.
17: * 3. Neither the name of the University nor the names of its contributors
18: * may be used to endorse or promote products derived from this software
19: * without specific prior written permission.
20: *
21: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
22: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
25: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31: * SUCH DAMAGE.
32: *
33: * @(#)dca.c 8.2 (Berkeley) 1/12/94
34: */
35:
36: /*
37: * Driver for the 98626/98644/internal serial interface on hp300/hp400,
38: * based on the National Semiconductor INS8250/NS16550AF/WD16C552 UARTs.
39: *
40: * N.B. On the hp700 and some hp300s, there is a "secret bit" with
41: * undocumented behavior. The third bit of the Modem Control Register
42: * (MCR_IEN == 0x08) must be set to enable interrupts. Failure to do
43: * so can result in deadlock on those machines, whereas the don't seem to
44: * be any harmful side-effects from setting this bit on non-affected
45: * machines.
46: */
47:
48: #include <sys/param.h>
49: #include <sys/systm.h>
50: #include <sys/ioctl.h>
51: #include <sys/proc.h>
52: #include <sys/tty.h>
53: #include <sys/conf.h>
54: #include <sys/file.h>
55: #include <sys/uio.h>
56: #include <sys/kernel.h>
57: #include <sys/syslog.h>
58: #include <sys/device.h>
59:
60: #include <machine/autoconf.h>
61: #include <machine/bus.h>
62: #include <machine/cpu.h>
63: #include <machine/intr.h>
64:
65: #include <dev/cons.h>
66:
67: #include <hp300/dev/dioreg.h>
68: #include <hp300/dev/diovar.h>
69: #include <hp300/dev/diodevs.h>
70: #include <hp300/dev/dcareg.h>
71:
72: #ifdef DDB
73: #include <ddb/db_var.h>
74: #endif
75:
76: struct dca_softc {
77: struct device sc_dev; /* generic device glue */
78: struct isr sc_isr;
79: struct dcadevice *sc_dca; /* pointer to hardware */
80: struct tty *sc_tty; /* our tty instance */
81: int sc_oflows; /* overflow counter */
82: short sc_flags; /* state flags */
83: u_char sc_cua; /* callout mode */
84:
85: /*
86: * Bits for sc_flags.
87: */
88: #define DCA_ACTIVE 0x0001 /* indicates live unit */
89: #define DCA_SOFTCAR 0x0002 /* indicates soft-carrier */
90: #define DCA_HASFIFO 0x0004 /* indicates unit has FIFO */
91: #define DCA_ISCONSOLE 0x0008 /* indicates unit is console */
92:
93: };
94:
95: int dcamatch(struct device *, void *, void *);
96: void dcaattach(struct device *, struct device *, void *);
97:
98: struct cfattach dca_ca = {
99: sizeof(struct dca_softc), dcamatch, dcaattach
100: };
101:
102: struct cfdriver dca_cd = {
103: NULL, "dca", DV_TTY
104: };
105:
106: int dcadefaultrate = TTYDEF_SPEED;
107: int dcamajor;
108:
109: cdev_decl(dca);
110:
111: int dcaintr(void *);
112: void dcaeint(struct dca_softc *, int);
113: void dcamint(struct dca_softc *);
114:
115: int dcaparam(struct tty *, struct termios *);
116: void dcastart(struct tty *);
117: int dcastop(struct tty *, int);
118: int dcamctl(struct dca_softc *, int, int);
119: void dcainit(struct dcadevice *, int);
120:
121: int dca_console_scan(int, caddr_t, void *);
122: cons_decl(dca);
123:
124: /*
125: * Stuff for DCA console support.
126: */
127: static struct dcadevice *dca_cn = NULL; /* pointer to hardware */
128: static int dcaconsinit; /* has been initialized */
129:
130: const struct speedtab dcaspeedtab[] = {
131: { 0, 0 },
132: { 50, DCABRD(50) },
133: { 75, DCABRD(75) },
134: { 110, DCABRD(110) },
135: { 134, DCABRD(134) },
136: { 150, DCABRD(150) },
137: { 200, DCABRD(200) },
138: { 300, DCABRD(300) },
139: { 600, DCABRD(600) },
140: { 1200, DCABRD(1200) },
141: { 1800, DCABRD(1800) },
142: { 2400, DCABRD(2400) },
143: { 4800, DCABRD(4800) },
144: { 9600, DCABRD(9600) },
145: { 19200, DCABRD(19200) },
146: { 38400, DCABRD(38400) },
147: { -1, -1 },
148: };
149:
150: #ifdef KGDB
151: #include <machine/remote-sl.h>
152:
153: extern dev_t kgdb_dev;
154: extern int kgdb_rate;
155: extern int kgdb_debug_init;
156: #endif
157:
158: #define DCAUNIT(x) (minor(x) & 0x7f)
159: #define DCACUA(x) (minor(x) & 0x80)
160:
161: #ifdef DEBUG
162: long fifoin[17];
163: long fifoout[17];
164: long dcaintrcount[16];
165: long dcamintcount[16];
166: #endif
167:
168: void dcainit(struct dcadevice *, int);
169:
170: int
171: dcamatch(parent, match, aux)
172: struct device *parent;
173: void *match, *aux;
174: {
175: struct dio_attach_args *da = aux;
176:
177: switch (da->da_id) {
178: case DIO_DEVICE_ID_DCA0:
179: case DIO_DEVICE_ID_DCA0REM:
180: case DIO_DEVICE_ID_DCA1:
181: case DIO_DEVICE_ID_DCA1REM:
182: return (1);
183: }
184:
185: return (0);
186: }
187:
188: void
189: dcaattach(parent, self, aux)
190: struct device *parent, *self;
191: void *aux;
192: {
193: struct dca_softc *sc = (struct dca_softc *)self;
194: struct dio_attach_args *da = aux;
195: struct dcadevice *dca;
196: int unit = self->dv_unit;
197: int scode = da->da_scode;
198: int ipl;
199:
200: if (scode == conscode) {
201: dca = (struct dcadevice *)conaddr;
202: sc->sc_flags |= DCA_ISCONSOLE;
203: DELAY(100000);
204:
205: /*
206: * We didn't know which unit this would be during
207: * the console probe, so we have to fixup cn_dev here.
208: */
209: cn_tab->cn_dev = makedev(dcamajor, unit);
210: } else {
211: dca = (struct dcadevice *)iomap(dio_scodetopa(da->da_scode),
212: da->da_size);
213: if (dca == NULL) {
214: printf("\n%s: can't map registers\n",
215: sc->sc_dev.dv_xname);
216: return;
217: }
218: }
219:
220: sc->sc_dca = dca;
221:
222: ipl = DIO_IPL(dca);
223: printf(" ipl %d", ipl);
224:
225: dca->dca_reset = 0xFF;
226: DELAY(100);
227:
228: /* look for a NS 16550AF UART with FIFOs */
229: dca->dca_fifo = FIFO_ENABLE|FIFO_RCV_RST|FIFO_XMT_RST|FIFO_TRIGGER_14;
230: DELAY(100);
231: if ((dca->dca_iir & IIR_FIFO_MASK) == IIR_FIFO_MASK)
232: sc->sc_flags |= DCA_HASFIFO;
233:
234: /* Establish interrupt handler. */
235: sc->sc_isr.isr_func = dcaintr;
236: sc->sc_isr.isr_arg = sc;
237: sc->sc_isr.isr_ipl = ipl;
238: sc->sc_isr.isr_priority =
239: (sc->sc_flags & DCA_HASFIFO) ? IPL_TTY : IPL_TTYNOBUF;
240: dio_intr_establish(&sc->sc_isr, self->dv_xname);
241:
242: sc->sc_flags |= DCA_ACTIVE;
243: if (self->dv_cfdata->cf_flags)
244: sc->sc_flags |= DCA_SOFTCAR;
245:
246: /* Enable interrupts. */
247: dca->dca_ic = IC_IE;
248:
249: /*
250: * Need to reset baud rate, etc. of next print so reset dcaconsinit.
251: * Also make sure console is always "hardwired."
252: */
253: if (sc->sc_flags & DCA_ISCONSOLE) {
254: dcaconsinit = 0;
255: sc->sc_flags |= DCA_SOFTCAR;
256: printf(": console, ");
257: } else
258: printf(": ");
259:
260: if (sc->sc_flags & DCA_HASFIFO)
261: printf("working fifo\n");
262: else
263: printf("no fifo\n");
264:
265: #ifdef KGDB
266: if (kgdb_dev == makedev(dcamajor, unit)) {
267: if (sc->sc_flags & DCA_ISCONSOLE)
268: kgdb_dev = NODEV; /* can't debug over console port */
269: else {
270: dcainit(dca, kgdb_rate);
271: dcaconsinit = 1; /* don't re-init in dcaputc */
272: if (kgdb_debug_init) {
273: /*
274: * Print prefix of device name,
275: * let kgdb_connect print the rest.
276: */
277: printf("%s: ", sc->sc_dev.dv_xname);
278: kgdb_connect(1);
279: } else
280: printf("%s: kgdb enabled\n",
281: sc->sc_dev.dv_xname);
282: }
283: }
284: #endif
285: }
286:
287: /* ARGSUSED */
288: int
289: dcaopen(dev, flag, mode, p)
290: dev_t dev;
291: int flag, mode;
292: struct proc *p;
293: {
294: int unit = DCAUNIT(dev);
295: struct dca_softc *sc;
296: struct tty *tp;
297: struct dcadevice *dca;
298: u_char code;
299: int s, error = 0;
300:
301: if (unit >= dca_cd.cd_ndevs ||
302: (sc = dca_cd.cd_devs[unit]) == NULL)
303: return (ENXIO);
304:
305: if ((sc->sc_flags & DCA_ACTIVE) == 0)
306: return (ENXIO);
307:
308: dca = sc->sc_dca;
309:
310: s = spltty();
311: if (sc->sc_tty == NULL) {
312: tp = sc->sc_tty = ttymalloc();
313: } else
314: tp = sc->sc_tty;
315: splx(s);
316:
317: tp->t_oproc = dcastart;
318: tp->t_param = dcaparam;
319: tp->t_dev = dev;
320:
321: if ((tp->t_state & TS_ISOPEN) == 0) {
322: /*
323: * Sanity clause: reset the card on first open.
324: * The card might be left in an inconsistent state
325: * if card memory is read inadvertently.
326: */
327: dcainit(dca, dcadefaultrate);
328:
329: tp->t_state |= TS_WOPEN;
330: ttychars(tp);
331: tp->t_iflag = TTYDEF_IFLAG;
332: tp->t_oflag = TTYDEF_OFLAG;
333: tp->t_cflag = TTYDEF_CFLAG;
334: tp->t_lflag = TTYDEF_LFLAG;
335: tp->t_ispeed = tp->t_ospeed = dcadefaultrate;
336:
337: s = spltty();
338:
339: dcaparam(tp, &tp->t_termios);
340: ttsetwater(tp);
341:
342: /* Set the FIFO threshold based on the receive speed. */
343: if (sc->sc_flags & DCA_HASFIFO)
344: dca->dca_fifo = FIFO_ENABLE | FIFO_RCV_RST |
345: FIFO_XMT_RST |
346: (tp->t_ispeed <= 1200 ? FIFO_TRIGGER_1 :
347: FIFO_TRIGGER_14);
348:
349: /* Flush any pending I/O */
350: while ((dca->dca_iir & IIR_IMASK) == IIR_RXRDY)
351: code = dca->dca_data;
352:
353: } else if (tp->t_state&TS_XCLUDE && p->p_ucred->cr_uid != 0)
354: return (EBUSY);
355: else
356: s = spltty();
357:
358: /* Set modem control state. */
359: (void) dcamctl(sc, MCR_DTR | MCR_RTS, DMSET);
360:
361: /* Set soft-carrier if so configured. */
362: if ((sc->sc_flags & DCA_SOFTCAR) || DCACUA(dev) ||
363: (dcamctl(sc, 0, DMGET) & MSR_DCD))
364: tp->t_state |= TS_CARR_ON;
365:
366: if (DCACUA(dev)) {
367: if (tp->t_state & TS_ISOPEN) {
368: /* Ah, but someone already is dialed in... */
369: splx(s);
370: return (EBUSY);
371: }
372: sc->sc_cua = 1; /* We go into CUA mode */
373: }
374:
375: /* Wait for carrier if necessary. */
376: if (flag & O_NONBLOCK) {
377: if (!DCACUA(dev) && sc->sc_cua) {
378: /* Opening TTY non-blocking... but the CUA is busy */
379: splx(s);
380: return (EBUSY);
381: }
382: } else {
383: while (sc->sc_cua ||
384: ((tp->t_cflag & CLOCAL) == 0 &&
385: (tp->t_state & TS_CARR_ON) == 0)) {
386: tp->t_state |= TS_WOPEN;
387: error = ttysleep(tp, (caddr_t)&tp->t_rawq,
388: TTIPRI | PCATCH, ttopen, 0);
389: if (!DCACUA(dev) && sc->sc_cua && error == EINTR)
390: continue;
391: if (error) {
392: if (DCACUA(dev))
393: sc->sc_cua = 0;
394: splx(s);
395: return (error);
396: }
397: if (!DCACUA(dev) && sc->sc_cua)
398: continue;
399: }
400: }
401: splx(s);
402:
403: if (error == 0)
404: error = (*linesw[tp->t_line].l_open)(dev, tp);
405:
406: return (error);
407: }
408:
409: /*ARGSUSED*/
410: int
411: dcaclose(dev, flag, mode, p)
412: dev_t dev;
413: int flag, mode;
414: struct proc *p;
415: {
416: struct dca_softc *sc;
417: struct tty *tp;
418: struct dcadevice *dca;
419: int unit;
420: int s;
421:
422: unit = DCAUNIT(dev);
423:
424: sc = dca_cd.cd_devs[unit];
425:
426: dca = sc->sc_dca;
427: tp = sc->sc_tty;
428: (*linesw[tp->t_line].l_close)(tp, flag);
429:
430: s = spltty();
431:
432: dca->dca_cfcr &= ~CFCR_SBREAK;
433: #ifdef KGDB
434: /* do not disable interrupts if debugging */
435: if (dev != kgdb_dev)
436: #endif
437: dca->dca_ier = 0;
438: if (tp->t_cflag & HUPCL && (sc->sc_flags & DCA_SOFTCAR) == 0) {
439: /* XXX perhaps only clear DTR */
440: (void) dcamctl(sc, 0, DMSET);
441: }
442: tp->t_state &= ~(TS_BUSY | TS_FLUSH);
443: sc->sc_cua = 0;
444: splx(s);
445: ttyclose(tp);
446: #if 0
447: ttyfree(tp);
448: sc->sc_tty = NULL;
449: #endif
450: return (0);
451: }
452:
453: int
454: dcaread(dev, uio, flag)
455: dev_t dev;
456: struct uio *uio;
457: int flag;
458: {
459: int unit = DCAUNIT(dev);
460: struct dca_softc *sc;
461: struct tty *tp;
462: int error, of;
463:
464: sc = dca_cd.cd_devs[unit];
465:
466: tp = sc->sc_tty;
467: of = sc->sc_oflows;
468: error = (*linesw[tp->t_line].l_read)(tp, uio, flag);
469: /*
470: * XXX hardly a reasonable thing to do, but reporting overflows
471: * at interrupt time just exacerbates the problem.
472: */
473: if (sc->sc_oflows != of)
474: log(LOG_WARNING, "%s: silo overflow\n", sc->sc_dev.dv_xname);
475: return (error);
476: }
477:
478: int
479: dcawrite(dev, uio, flag)
480: dev_t dev;
481: struct uio *uio;
482: int flag;
483: {
484: struct dca_softc *sc = dca_cd.cd_devs[DCAUNIT(dev)];
485: struct tty *tp = sc->sc_tty;
486:
487: return ((*linesw[tp->t_line].l_write)(tp, uio, flag));
488: }
489:
490: struct tty *
491: dcatty(dev)
492: dev_t dev;
493: {
494: struct dca_softc *sc = dca_cd.cd_devs[DCAUNIT(dev)];
495:
496: return (sc->sc_tty);
497: }
498:
499: int
500: dcaintr(arg)
501: void *arg;
502: {
503: struct dca_softc *sc = arg;
504: #ifdef KGDB
505: int unit = sc->sc_dev.dv_unit;
506: #endif
507: struct dcadevice *dca = sc->sc_dca;
508: struct tty *tp = sc->sc_tty;
509: u_char code;
510: int iflowdone = 0;
511:
512: /*
513: * If interrupts aren't enabled, then the interrupt can't
514: * be for us.
515: */
516: if ((dca->dca_ic & (IC_IR|IC_IE)) != (IC_IR|IC_IE))
517: return (0);
518:
519: for (;;) {
520: code = dca->dca_iir;
521: #ifdef DEBUG
522: dcaintrcount[code & IIR_IMASK]++;
523: #endif
524:
525: switch (code & IIR_IMASK) {
526: case IIR_NOPEND:
527: return (1);
528: case IIR_RXTOUT:
529: case IIR_RXRDY:
530: /* do time-critical read in-line */
531: /*
532: * Process a received byte. Inline for speed...
533: */
534: #ifdef KGDB
535: #define RCVBYTE() \
536: code = dca->dca_data; \
537: if (tp != NULL) { \
538: if ((tp->t_state & TS_ISOPEN) == 0) { \
539: if (code == FRAME_END && \
540: kgdb_dev == makedev(dcamajor, unit)) \
541: kgdb_connect(0); /* trap into kgdb */ \
542: } else \
543: (*linesw[tp->t_line].l_rint)(code, tp) \
544: }
545: #else
546: #define RCVBYTE() \
547: code = dca->dca_data; \
548: if (tp != NULL && (tp->t_state & TS_ISOPEN) != 0) \
549: (*linesw[tp->t_line].l_rint)(code, tp)
550: #endif
551: RCVBYTE();
552: if (sc->sc_flags & DCA_HASFIFO) {
553: #ifdef DEBUG
554: int fifocnt = 1;
555: #endif
556: while ((code = dca->dca_lsr) & LSR_RCV_MASK) {
557: if (code == LSR_RXRDY) {
558: RCVBYTE();
559: } else
560: dcaeint(sc, code);
561: #ifdef DEBUG
562: fifocnt++;
563: #endif
564: }
565: #ifdef DEBUG
566: if (fifocnt > 16)
567: fifoin[0]++;
568: else
569: fifoin[fifocnt]++;
570: #endif
571: }
572: if (!iflowdone && (tp->t_cflag&CRTS_IFLOW) &&
573: tp->t_rawq.c_cc > TTYHOG/2) {
574: dca->dca_mcr &= ~MCR_RTS;
575: iflowdone = 1;
576: }
577: break;
578: case IIR_TXRDY:
579: if (tp != NULL) {
580: tp->t_state &=~ (TS_BUSY|TS_FLUSH);
581: if (tp->t_line)
582: (*linesw[tp->t_line].l_start)(tp);
583: else
584: dcastart(tp);
585: }
586: break;
587: case IIR_RLS:
588: dcaeint(sc, dca->dca_lsr);
589: break;
590: default:
591: if (code & IIR_NOPEND)
592: return (1);
593: log(LOG_WARNING, "%s: weird interrupt: 0x%x\n",
594: sc->sc_dev.dv_xname, code);
595: /* FALLTHROUGH */
596: case IIR_MLSC:
597: dcamint(sc);
598: break;
599: }
600: }
601: }
602:
603: void
604: dcaeint(sc, stat)
605: struct dca_softc *sc;
606: int stat;
607: {
608: struct tty *tp = sc->sc_tty;
609: struct dcadevice *dca = sc->sc_dca;
610: int c;
611:
612: c = dca->dca_data;
613:
614: #if defined(DDB) && !defined(KGDB)
615: if ((sc->sc_flags & DCA_ISCONSOLE) && db_console && (stat & LSR_BI)) {
616: Debugger();
617: return;
618: }
619: #endif
620:
621: if (tp == NULL)
622: return;
623:
624: if ((tp->t_state & TS_ISOPEN) == 0) {
625: #ifdef KGDB
626: /* we don't care about parity errors */
627: if (((stat & (LSR_BI|LSR_FE|LSR_PE)) == LSR_PE) &&
628: kgdb_dev == makedev(dcamajor, sc->sc_hd->hp_unit) &&
629: c == FRAME_END)
630: kgdb_connect(0); /* trap into kgdb */
631: #endif
632: return;
633: }
634:
635: if (stat & (LSR_BI | LSR_FE))
636: c |= TTY_FE;
637: else if (stat & LSR_PE)
638: c |= TTY_PE;
639: else if (stat & LSR_OE)
640: sc->sc_oflows++;
641: (*linesw[tp->t_line].l_rint)(c, tp);
642: }
643:
644: void
645: dcamint(sc)
646: struct dca_softc *sc;
647: {
648: struct tty *tp = sc->sc_tty;
649: struct dcadevice *dca = sc->sc_dca;
650: u_char stat;
651:
652: stat = dca->dca_msr;
653: #ifdef DEBUG
654: dcamintcount[stat & 0xf]++;
655: #endif
656:
657: if (tp == NULL)
658: return;
659:
660: if ((stat & MSR_DDCD) &&
661: (sc->sc_flags & DCA_SOFTCAR) == 0) {
662: if (stat & MSR_DCD)
663: (void)(*linesw[tp->t_line].l_modem)(tp, 1);
664: else if ((*linesw[tp->t_line].l_modem)(tp, 0) == 0)
665: dca->dca_mcr &= ~(MCR_DTR | MCR_RTS);
666: }
667: /*
668: * CTS change.
669: * If doing HW output flow control start/stop output as appropriate.
670: */
671: if ((stat & MSR_DCTS) &&
672: (tp->t_state & TS_ISOPEN) && (tp->t_cflag & CCTS_OFLOW)) {
673: if (stat & MSR_CTS) {
674: tp->t_state &=~ TS_TTSTOP;
675: dcastart(tp);
676: } else {
677: tp->t_state |= TS_TTSTOP;
678: }
679: }
680: }
681:
682: int
683: dcaioctl(dev, cmd, data, flag, p)
684: dev_t dev;
685: u_long cmd;
686: caddr_t data;
687: int flag;
688: struct proc *p;
689: {
690: int unit = DCAUNIT(dev);
691: struct dca_softc *sc = dca_cd.cd_devs[unit];
692: struct tty *tp = sc->sc_tty;
693: struct dcadevice *dca = sc->sc_dca;
694: int error;
695:
696: error = (*linesw[tp->t_line].l_ioctl)(tp, cmd, data, flag, p);
697: if (error >= 0)
698: return (error);
699: error = ttioctl(tp, cmd, data, flag, p);
700: if (error >= 0)
701: return (error);
702:
703: switch (cmd) {
704: case TIOCSBRK:
705: dca->dca_cfcr |= CFCR_SBREAK;
706: break;
707:
708: case TIOCCBRK:
709: dca->dca_cfcr &= ~CFCR_SBREAK;
710: break;
711:
712: case TIOCSDTR:
713: (void) dcamctl(sc, MCR_DTR | MCR_RTS, DMBIS);
714: break;
715:
716: case TIOCCDTR:
717: (void) dcamctl(sc, MCR_DTR | MCR_RTS, DMBIC);
718: break;
719:
720: case TIOCMSET:
721: (void) dcamctl(sc, *(int *)data, DMSET);
722: break;
723:
724: case TIOCMBIS:
725: (void) dcamctl(sc, *(int *)data, DMBIS);
726: break;
727:
728: case TIOCMBIC:
729: (void) dcamctl(sc, *(int *)data, DMBIC);
730: break;
731:
732: case TIOCMGET:
733: *(int *)data = dcamctl(sc, 0, DMGET);
734: break;
735:
736: case TIOCGFLAGS: {
737: int bits = 0;
738:
739: if (sc->sc_flags & DCA_SOFTCAR)
740: bits |= TIOCFLAG_SOFTCAR;
741:
742: if (tp->t_cflag & CLOCAL)
743: bits |= TIOCFLAG_CLOCAL;
744:
745: *(int *)data = bits;
746: break;
747: }
748:
749: case TIOCSFLAGS: {
750: int userbits;
751:
752: error = suser(p, 0);
753: if (error)
754: return (EPERM);
755:
756: userbits = *(int *)data;
757:
758: if ((userbits & TIOCFLAG_SOFTCAR) ||
759: (sc->sc_flags & DCA_ISCONSOLE))
760: sc->sc_flags |= DCA_SOFTCAR;
761:
762: if (userbits & TIOCFLAG_CLOCAL)
763: tp->t_cflag |= CLOCAL;
764:
765: break;
766: }
767:
768: default:
769: return (ENOTTY);
770: }
771: return (0);
772: }
773:
774: int
775: dcaparam(tp, t)
776: struct tty *tp;
777: struct termios *t;
778: {
779: int unit = DCAUNIT(tp->t_dev);
780: struct dca_softc *sc = dca_cd.cd_devs[unit];
781: struct dcadevice *dca = sc->sc_dca;
782: int cfcr, cflag = t->c_cflag;
783: int ospeed = ttspeedtab(t->c_ospeed, dcaspeedtab);
784: int s;
785:
786: /* check requested parameters */
787: if (ospeed < 0 || (t->c_ispeed && t->c_ispeed != t->c_ospeed))
788: return (EINVAL);
789:
790: switch (cflag & CSIZE) {
791: case CS5:
792: cfcr = CFCR_5BITS;
793: break;
794:
795: case CS6:
796: cfcr = CFCR_6BITS;
797: break;
798:
799: case CS7:
800: cfcr = CFCR_7BITS;
801: break;
802:
803: case CS8:
804: default: /* XXX gcc whines about cfcr being unitialized... */
805: cfcr = CFCR_8BITS;
806: break;
807: }
808: if (cflag & PARENB) {
809: cfcr |= CFCR_PENAB;
810: if ((cflag & PARODD) == 0)
811: cfcr |= CFCR_PEVEN;
812: }
813: if (cflag & CSTOPB)
814: cfcr |= CFCR_STOPB;
815:
816: s = spltty();
817:
818: if (ospeed == 0)
819: (void) dcamctl(sc, 0, DMSET); /* hang up line */
820:
821: /*
822: * Set the FIFO threshold based on the receive speed, if we
823: * are changing it.
824: */
825: if (tp->t_ispeed != t->c_ispeed) {
826: if (sc->sc_flags & DCA_HASFIFO)
827: dca->dca_fifo = FIFO_ENABLE |
828: (t->c_ispeed <= 1200 ? FIFO_TRIGGER_1 :
829: FIFO_TRIGGER_14);
830: }
831:
832: if (ospeed != 0) {
833: dca->dca_cfcr |= CFCR_DLAB;
834: dca->dca_data = ospeed & 0xFF;
835: dca->dca_ier = ospeed >> 8;
836: dca->dca_cfcr = cfcr;
837: } else
838: dca->dca_cfcr = cfcr;
839:
840: /* and copy to tty */
841: tp->t_ispeed = t->c_ispeed;
842: tp->t_ospeed = t->c_ospeed;
843: tp->t_cflag = cflag;
844:
845: dca->dca_ier = IER_ERXRDY | IER_ETXRDY | IER_ERLS | IER_EMSC;
846: dca->dca_mcr |= MCR_IEN;
847:
848: splx(s);
849: return (0);
850: }
851:
852: void
853: dcastart(tp)
854: struct tty *tp;
855: {
856: int s, c, unit = DCAUNIT(tp->t_dev);
857: struct dca_softc *sc = dca_cd.cd_devs[unit];
858: struct dcadevice *dca = sc->sc_dca;
859:
860: s = spltty();
861:
862: if (tp->t_state & (TS_TIMEOUT|TS_TTSTOP))
863: goto out;
864: if (tp->t_outq.c_cc <= tp->t_lowat) {
865: if (tp->t_state & TS_ASLEEP) {
866: tp->t_state &= ~TS_ASLEEP;
867: wakeup((caddr_t)&tp->t_outq);
868: }
869: if (tp->t_outq.c_cc == 0)
870: goto out;
871: selwakeup(&tp->t_wsel);
872: }
873: if (dca->dca_lsr & LSR_TXRDY) {
874: tp->t_state |= TS_BUSY;
875: if (sc->sc_flags & DCA_HASFIFO) {
876: for (c = 0; c < 16 && tp->t_outq.c_cc; ++c)
877: dca->dca_data = getc(&tp->t_outq);
878: #ifdef DEBUG
879: if (c > 16)
880: fifoout[0]++;
881: else
882: fifoout[c]++;
883: #endif
884: } else
885: dca->dca_data = getc(&tp->t_outq);
886: }
887:
888: out:
889: splx(s);
890: }
891:
892: /*
893: * Stop output on a line.
894: */
895: /*ARGSUSED*/
896: int
897: dcastop(tp, flag)
898: struct tty *tp;
899: int flag;
900: {
901: int s;
902:
903: s = spltty();
904: if (tp->t_state & TS_BUSY)
905: if ((tp->t_state & TS_TTSTOP) == 0)
906: tp->t_state |= TS_FLUSH;
907: splx(s);
908: return (0);
909: }
910:
911: int
912: dcamctl(sc, bits, how)
913: struct dca_softc *sc;
914: int bits, how;
915: {
916: struct dcadevice *dca = sc->sc_dca;
917: int s;
918:
919: /*
920: * Always make sure MCR_IEN is set (unless setting to 0)
921: */
922: #ifdef KGDB
923: if (how == DMSET && kgdb_dev == makedev(dcamajor, sc->sc_hd->hp_unit))
924: bits |= MCR_IEN;
925: else
926: #endif
927: if (how == DMBIS || (how == DMSET && bits))
928: bits |= MCR_IEN;
929: else if (how == DMBIC)
930: bits &= ~MCR_IEN;
931: s = spltty();
932:
933: switch (how) {
934: case DMSET:
935: dca->dca_mcr = bits;
936: break;
937:
938: case DMBIS:
939: dca->dca_mcr |= bits;
940: break;
941:
942: case DMBIC:
943: dca->dca_mcr &= ~bits;
944: break;
945:
946: case DMGET:
947: bits = dca->dca_msr;
948: break;
949: }
950: splx(s);
951: return (bits);
952: }
953:
954: void
955: dcainit(dca, rate)
956: struct dcadevice *dca;
957: int rate;
958: {
959: int s;
960: short stat;
961:
962: s = splhigh();
963:
964: dca->dca_reset = 0xFF;
965: DELAY(100);
966: dca->dca_ic = IC_IE;
967:
968: dca->dca_cfcr = CFCR_DLAB;
969: rate = ttspeedtab(rate, dcaspeedtab);
970: dca->dca_data = rate & 0xFF;
971: dca->dca_ier = rate >> 8;
972: dca->dca_cfcr = CFCR_8BITS;
973: dca->dca_ier = IER_ERXRDY | IER_ETXRDY;
974: dca->dca_fifo =
975: FIFO_ENABLE | FIFO_RCV_RST | FIFO_XMT_RST | FIFO_TRIGGER_1;
976: dca->dca_mcr = MCR_DTR | MCR_RTS;
977: DELAY(100);
978: stat = dca->dca_iir;
979: splx(s);
980: }
981:
982: /*
983: * Following are all routines needed for DCA to act as console
984: */
985:
986: int
987: dca_console_scan(scode, va, arg)
988: int scode;
989: caddr_t va;
990: void *arg;
991: {
992: struct dcadevice *dca = (struct dcadevice *)va;
993: struct consdev *cp = arg;
994: u_int pri;
995:
996: switch (dca->dca_id) {
997: case DCAID0:
998: case DCAID1:
999: pri = CN_NORMAL;
1000: break;
1001:
1002: case DCAID0 | DCACON:
1003: case DCAID1 | DCACON:
1004: pri = CN_REMOTE;
1005: break;
1006:
1007: default:
1008: return (0);
1009: }
1010:
1011: #ifdef CONSCODE
1012: /*
1013: * Raise our priority, if appropriate.
1014: */
1015: if (scode == CONSCODE)
1016: pri = CN_FORCED;
1017: #endif
1018:
1019: /* Only raise priority. */
1020: if (pri > cp->cn_pri)
1021: cp->cn_pri = pri;
1022:
1023: /*
1024: * If our priority is higher than the currently-remembered
1025: * console, stash our priority, for the benefit of dcacninit().
1026: */
1027: if (cn_tab == NULL || cp->cn_pri > cn_tab->cn_pri) {
1028: cn_tab = cp;
1029: conscode = scode;
1030: return (DIO_SIZE(scode, va));
1031: }
1032: return (0);
1033: }
1034:
1035: void
1036: dcacnprobe(cp)
1037: struct consdev *cp;
1038: {
1039:
1040: /* locate the major number */
1041: for (dcamajor = 0; dcamajor < nchrdev; dcamajor++)
1042: if (cdevsw[dcamajor].d_open == dcaopen)
1043: break;
1044:
1045: /* initialize required fields */
1046: cp->cn_dev = makedev(dcamajor, 0); /* XXX */
1047:
1048: console_scan(dca_console_scan, cp);
1049:
1050: #ifdef KGDB
1051: /* XXX this needs to be fixed. */
1052: if (major(kgdb_dev) == 1) /* XXX */
1053: kgdb_dev = makedev(dcamajor, minor(kgdb_dev));
1054: #endif
1055: }
1056:
1057: /* ARGSUSED */
1058: void
1059: dcacninit(cp)
1060: struct consdev *cp;
1061: {
1062:
1063: /*
1064: * We are not interested by the second console pass.
1065: */
1066: if (consolepass != 0)
1067: return;
1068:
1069: dca_cn = (struct dcadevice *)conaddr;
1070: dcainit(dca_cn, dcadefaultrate);
1071: dcaconsinit = 1;
1072: }
1073:
1074: /* ARGSUSED */
1075: int
1076: dcacngetc(dev)
1077: dev_t dev;
1078: {
1079: u_char stat;
1080: int c, s;
1081:
1082: #ifdef lint
1083: stat = dev; if (stat) return (0);
1084: #endif
1085:
1086: s = splhigh();
1087: while (((stat = dca_cn->dca_lsr) & LSR_RXRDY) == 0)
1088: ;
1089: c = dca_cn->dca_data;
1090: stat = dca_cn->dca_iir;
1091: splx(s);
1092: return (c);
1093: }
1094:
1095: /*
1096: * Console kernel output character routine.
1097: */
1098: /* ARGSUSED */
1099: void
1100: dcacnputc(dev, c)
1101: dev_t dev;
1102: int c;
1103: {
1104: int timo;
1105: u_char stat;
1106: int s = splhigh();
1107:
1108: #ifdef lint
1109: stat = dev; if (stat) return;
1110: #endif
1111:
1112: if (dcaconsinit == 0) {
1113: dcainit(dca_cn, dcadefaultrate);
1114: dcaconsinit = 1;
1115: }
1116: /* wait for any pending transmission to finish */
1117: timo = 50000;
1118: while (((stat = dca_cn->dca_lsr) & LSR_TXRDY) == 0 && --timo)
1119: ;
1120: dca_cn->dca_data = c;
1121: /* wait for this transmission to complete */
1122: timo = 1500000;
1123: while (((stat = dca_cn->dca_lsr) & LSR_TXRDY) == 0 && --timo)
1124: ;
1125: /* clear any interrupts generated by this transmission */
1126: stat = dca_cn->dca_iir;
1127: splx(s);
1128: }