![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to com.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 com.c CVS log | Up to [Net/2] / Net2 / arch / i386 / isa |
1.1 root 1: /*-
2: * Copyright (c) 1991 The Regents of the University of California.
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 product includes software developed by the University of
16: * California, Berkeley and its contributors.
17: * 4. 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: * @(#)com.c 7.5 (Berkeley) 5/16/91
34: */
35:
36: #include "com.h"
37: #if NCOM > 0
38: /*
39: * COM driver, based on HP dca driver
40: * uses National Semiconductor NS16450/NS16550AF UART
41: */
42: #include "param.h"
43: #include "systm.h"
44: #include "ioctl.h"
45: #include "tty.h"
46: #include "proc.h"
47: #include "user.h"
48: #include "conf.h"
49: #include "file.h"
50: #include "uio.h"
51: #include "kernel.h"
52: #include "syslog.h"
53:
54: #include "i386/isa/isa_device.h"
55: #include "i386/isa/comreg.h"
56: #include "i386/isa/ic/ns16550.h"
57:
58: int comprobe(), comattach(), comintr(), comstart(), comparam();
59:
60: struct isa_driver comdriver = {
61: comprobe, comattach, "com"
62: };
63:
64: int comsoftCAR;
65: int com_active;
66: int com_hasfifo;
67: int ncom = NCOM;
68: #ifdef COMCONSOLE
69: int comconsole = COMCONSOLE;
70: #else
71: int comconsole = -1;
72: #endif
73: int comconsinit;
74: int comdefaultrate = TTYDEF_SPEED;
75: int commajor;
76: short com_addr[NCOM];
77: struct tty com_tty[NCOM];
78:
79: struct speedtab comspeedtab[] = {
80: 0, 0,
81: 50, COMBRD(50),
82: 75, COMBRD(75),
83: 110, COMBRD(110),
84: 134, COMBRD(134),
85: 150, COMBRD(150),
86: 200, COMBRD(200),
87: 300, COMBRD(300),
88: 600, COMBRD(600),
89: 1200, COMBRD(1200),
90: 1800, COMBRD(1800),
91: 2400, COMBRD(2400),
92: 4800, COMBRD(4800),
93: 9600, COMBRD(9600),
94: 19200, COMBRD(19200),
95: 38400, COMBRD(38400),
96: 57600, COMBRD(57600),
97: -1, -1
98: };
99:
100: extern struct tty *constty;
101: #ifdef KGDB
102: #include "machine/remote-sl.h"
103:
104: extern int kgdb_dev;
105: extern int kgdb_rate;
106: extern int kgdb_debug_init;
107: #endif
108:
109: #define UNIT(x) minor(x)
110:
111: comprobe(dev)
112: struct isa_device *dev;
113: {
114: /* force access to id reg */
115: outb(dev->id_iobase+com_cfcr, 0);
116: outb(dev->id_iobase+com_iir, 0);
117: if ((inb(dev->id_iobase+com_iir) & 0x38) == 0)
118: return(1);
119: return(1);
120:
121: }
122:
123:
124: int
125: comattach(isdp)
126: struct isa_device *isdp;
127: {
128: struct tty *tp;
129: u_char unit;
130: int port = isdp->id_iobase;
131:
132: unit = isdp->id_unit;
133: if (unit == comconsole)
134: DELAY(100000);
135: com_addr[unit] = port;
136: com_active |= 1 << unit;
137: comsoftCAR |= 1 << unit; /* XXX */
138:
139: /* look for a NS 16550AF UART with FIFOs */
140: outb(port+com_fifo, FIFO_ENABLE|FIFO_RCV_RST|FIFO_XMT_RST|FIFO_TRIGGER_14);
141: DELAY(100);
142: if ((inb(port+com_iir) & IIR_FIFO_MASK) == IIR_FIFO_MASK)
143: com_hasfifo |= 1 << unit;
144:
145: outb(port+com_ier, 0);
146: outb(port+com_mcr, 0 | MCR_IENABLE);
147: #ifdef KGDB
148: if (kgdb_dev == makedev(commajor, unit)) {
149: if (comconsole == unit)
150: kgdb_dev = -1; /* can't debug over console port */
151: else {
152: (void) cominit(unit, kgdb_rate);
153: if (kgdb_debug_init) {
154: /*
155: * Print prefix of device name,
156: * let kgdb_connect print the rest.
157: */
158: printf("com%d: ", unit);
159: kgdb_connect(1);
160: } else
161: printf("com%d: kgdb enabled\n", unit);
162: }
163: }
164: #endif
165: /*
166: * Need to reset baud rate, etc. of next print so reset comconsinit.
167: * Also make sure console is always "hardwired"
168: */
169: if (unit == comconsole) {
170: comconsinit = 0;
171: comsoftCAR |= (1 << unit);
172: }
173: return (1);
174: }
175:
176: /* ARGSUSED */
177: #ifdef __STDC__
178: comopen(dev_t dev, int flag, int mode, struct proc *p)
179: #else
180: comopen(dev, flag, mode, p)
181: dev_t dev;
182: int flag, mode;
183: struct proc *p;
184: #endif
185: {
186: register struct tty *tp;
187: register int unit;
188: int error = 0;
189:
190: unit = UNIT(dev);
191: if (unit >= NCOM || (com_active & (1 << unit)) == 0)
192: return (ENXIO);
193: tp = &com_tty[unit];
194: tp->t_oproc = comstart;
195: tp->t_param = comparam;
196: tp->t_dev = dev;
197: if ((tp->t_state & TS_ISOPEN) == 0) {
198: tp->t_state |= TS_WOPEN;
199: ttychars(tp);
200: if (tp->t_ispeed == 0) {
201: tp->t_iflag = TTYDEF_IFLAG;
202: tp->t_oflag = TTYDEF_OFLAG;
203: tp->t_cflag = TTYDEF_CFLAG;
204: tp->t_lflag = TTYDEF_LFLAG;
205: tp->t_ispeed = tp->t_ospeed = comdefaultrate;
206: }
207: comparam(tp, &tp->t_termios);
208: ttsetwater(tp);
209: } else if (tp->t_state&TS_XCLUDE && p->p_ucred->cr_uid != 0)
210: return (EBUSY);
211: (void) spltty();
212: (void) commctl(dev, MCR_DTR | MCR_RTS, DMSET);
213: if ((comsoftCAR & (1 << unit)) || (commctl(dev, 0, DMGET) & MSR_DCD))
214: tp->t_state |= TS_CARR_ON;
215: while ((flag&O_NONBLOCK) == 0 && (tp->t_cflag&CLOCAL) == 0 &&
216: (tp->t_state & TS_CARR_ON) == 0) {
217: tp->t_state |= TS_WOPEN;
218: if (error = ttysleep(tp, (caddr_t)&tp->t_rawq, TTIPRI | PCATCH,
219: ttopen, 0))
220: break;
221: }
222: (void) spl0();
223: if (error == 0)
224: error = (*linesw[tp->t_line].l_open)(dev, tp);
225: return (error);
226: }
227:
228: /*ARGSUSED*/
229: comclose(dev, flag, mode, p)
230: dev_t dev;
231: int flag, mode;
232: struct proc *p;
233: {
234: register struct tty *tp;
235: register com;
236: register int unit;
237:
238: unit = UNIT(dev);
239: com = com_addr[unit];
240: tp = &com_tty[unit];
241: (*linesw[tp->t_line].l_close)(tp, flag);
242: outb(com+com_cfcr, inb(com+com_cfcr) & ~CFCR_SBREAK);
243: #ifdef KGDB
244: /* do not disable interrupts if debugging */
245: if (kgdb_dev != makedev(commajor, unit))
246: #endif
247: outb(com+com_ier, 0);
248: if (tp->t_cflag&HUPCL || tp->t_state&TS_WOPEN ||
249: (tp->t_state&TS_ISOPEN) == 0)
250: (void) commctl(dev, 0, DMSET);
251: ttyclose(tp);
252: return(0);
253: }
254:
255: comread(dev, uio, flag)
256: dev_t dev;
257: struct uio *uio;
258: {
259: register struct tty *tp = &com_tty[UNIT(dev)];
260:
261: return ((*linesw[tp->t_line].l_read)(tp, uio, flag));
262: }
263:
264: comwrite(dev, uio, flag)
265: dev_t dev;
266: struct uio *uio;
267: {
268: int unit = UNIT(dev);
269: register struct tty *tp = &com_tty[unit];
270:
271: /*
272: * (XXX) We disallow virtual consoles if the physical console is
273: * a serial port. This is in case there is a display attached that
274: * is not the console. In that situation we don't need/want the X
275: * server taking over the console.
276: */
277: if (constty && unit == comconsole)
278: constty = NULL;
279: return ((*linesw[tp->t_line].l_write)(tp, uio, flag));
280: }
281:
282: comintr(unit)
283: register int unit;
284: {
285: register com;
286: register u_char code;
287: register struct tty *tp;
288:
289: com = com_addr[unit];
290: while (1) {
291: code = inb(com+com_iir);
292: switch (code & IIR_IMASK) {
293: case IIR_NOPEND:
294: return (1);
295: case IIR_RXTOUT:
296: case IIR_RXRDY:
297: tp = &com_tty[unit];
298: /*
299: * Process received bytes. Inline for speed...
300: */
301: #ifdef KGDB
302: #define RCVBYTE() \
303: code = inb(com+com_data); \
304: if ((tp->t_state & TS_ISOPEN) == 0) { \
305: if (kgdb_dev == makedev(commajor, unit) && \
306: code == FRAME_END) \
307: kgdb_connect(0); /* trap into kgdb */ \
308: } else \
309: (*linesw[tp->t_line].l_rint)(code, tp)
310: #else
311: #define RCVBYTE() \
312: code = inb(com+com_data); \
313: if (tp->t_state & TS_ISOPEN) \
314: (*linesw[tp->t_line].l_rint)(code, tp)
315: #endif
316:
317: RCVBYTE();
318:
319: if (com_hasfifo & (1 << unit))
320: while ((code = inb(com+com_lsr)) & LSR_RCV_MASK) {
321: if (code == LSR_RXRDY) {
322: RCVBYTE();
323: } else
324: comeint(unit, code, com);
325: }
326: break;
327: case IIR_TXRDY:
328: tp = &com_tty[unit];
329: tp->t_state &=~ (TS_BUSY|TS_FLUSH);
330: if (tp->t_line)
331: (*linesw[tp->t_line].l_start)(tp);
332: else
333: comstart(tp);
334: break;
335: case IIR_RLS:
336: comeint(unit, inb(com+com_lsr), com);
337: break;
338: default:
339: if (code & IIR_NOPEND)
340: return (1);
341: log(LOG_WARNING, "com%d: weird interrupt: 0x%x\n",
342: unit, code);
343: /* fall through */
344: case IIR_MLSC:
345: commint(unit, com);
346: break;
347: }
348: }
349: }
350:
351: comeint(unit, stat, com)
352: register int unit, stat;
353: register com;
354: {
355: register struct tty *tp;
356: register int c;
357:
358: tp = &com_tty[unit];
359: c = inb(com+com_data);
360: if ((tp->t_state & TS_ISOPEN) == 0) {
361: #ifdef KGDB
362: /* we don't care about parity errors */
363: if (((stat & (LSR_BI|LSR_FE|LSR_PE)) == LSR_PE) &&
364: kgdb_dev == makedev(commajor, unit) && c == FRAME_END)
365: kgdb_connect(0); /* trap into kgdb */
366: #endif
367: return;
368: }
369: if (stat & (LSR_BI | LSR_FE))
370: c |= TTY_FE;
371: else if (stat & LSR_PE)
372: c |= TTY_PE;
373: else if (stat & LSR_OE)
374: log(LOG_WARNING, "com%d: silo overflow\n", unit);
375: (*linesw[tp->t_line].l_rint)(c, tp);
376: }
377:
378: commint(unit, com)
379: register int unit;
380: register com;
381: {
382: register struct tty *tp;
383: register int stat;
384:
385: tp = &com_tty[unit];
386: stat = inb(com+com_msr);
387: if ((stat & MSR_DDCD) && (comsoftCAR & (1 << unit)) == 0) {
388: if (stat & MSR_DCD)
389: (void)(*linesw[tp->t_line].l_modem)(tp, 1);
390: else if ((*linesw[tp->t_line].l_modem)(tp, 0) == 0)
391: outb(com+com_mcr,
392: inb(com+com_mcr) & ~(MCR_DTR | MCR_RTS) | MCR_IENABLE);
393: } else if ((stat & MSR_DCTS) && (tp->t_state & TS_ISOPEN) &&
394: (tp->t_flags & CRTSCTS)) {
395: /* the line is up and we want to do rts/cts flow control */
396: if (stat & MSR_CTS) {
397: tp->t_state &=~ TS_TTSTOP;
398: ttstart(tp);
399: } else
400: tp->t_state |= TS_TTSTOP;
401: }
402: }
403:
404: comioctl(dev, cmd, data, flag)
405: dev_t dev;
406: caddr_t data;
407: {
408: register struct tty *tp;
409: register int unit = UNIT(dev);
410: register com;
411: register int error;
412:
413: tp = &com_tty[unit];
414: error = (*linesw[tp->t_line].l_ioctl)(tp, cmd, data, flag);
415: if (error >= 0)
416: return (error);
417: error = ttioctl(tp, cmd, data, flag);
418: if (error >= 0)
419: return (error);
420:
421: com = com_addr[unit];
422: switch (cmd) {
423:
424: case TIOCSBRK:
425: outb(com+com_cfcr, inb(com+com_cfcr) | CFCR_SBREAK);
426: break;
427:
428: case TIOCCBRK:
429: outb(com+com_cfcr, inb(com+com_cfcr) & ~CFCR_SBREAK);
430: break;
431:
432: case TIOCSDTR:
433: (void) commctl(dev, MCR_DTR | MCR_RTS, DMBIS);
434: break;
435:
436: case TIOCCDTR:
437: (void) commctl(dev, MCR_DTR | MCR_RTS, DMBIC);
438: break;
439:
440: case TIOCMSET:
441: (void) commctl(dev, *(int *)data, DMSET);
442: break;
443:
444: case TIOCMBIS:
445: (void) commctl(dev, *(int *)data, DMBIS);
446: break;
447:
448: case TIOCMBIC:
449: (void) commctl(dev, *(int *)data, DMBIC);
450: break;
451:
452: case TIOCMGET:
453: *(int *)data = commctl(dev, 0, DMGET);
454: break;
455:
456: default:
457: return (ENOTTY);
458: }
459: return (0);
460: }
461:
462: comparam(tp, t)
463: register struct tty *tp;
464: register struct termios *t;
465: {
466: register com;
467: register int cfcr, cflag = t->c_cflag;
468: int unit = UNIT(tp->t_dev);
469: int ospeed = ttspeedtab(t->c_ospeed, comspeedtab);
470:
471: /* check requested parameters */
472: if (ospeed < 0 || (t->c_ispeed && t->c_ispeed != t->c_ospeed))
473: return(EINVAL);
474: /* and copy to tty */
475: tp->t_ispeed = t->c_ispeed;
476: tp->t_ospeed = t->c_ospeed;
477: tp->t_cflag = cflag;
478:
479: com = com_addr[unit];
480: outb(com+com_ier, IER_ERXRDY | IER_ETXRDY | IER_ERLS /*| IER_EMSC*/);
481: if (ospeed == 0) {
482: (void) commctl(unit, 0, DMSET); /* hang up line */
483: return(0);
484: }
485: outb(com+com_cfcr, inb(com+com_cfcr) | CFCR_DLAB);
486: outb(com+com_data, ospeed & 0xFF);
487: outb(com+com_ier, ospeed >> 8);
488: switch (cflag&CSIZE) {
489: case CS5:
490: cfcr = CFCR_5BITS; break;
491: case CS6:
492: cfcr = CFCR_6BITS; break;
493: case CS7:
494: cfcr = CFCR_7BITS; break;
495: case CS8:
496: cfcr = CFCR_8BITS; break;
497: }
498: if (cflag&PARENB) {
499: cfcr |= CFCR_PENAB;
500: if ((cflag&PARODD) == 0)
501: cfcr |= CFCR_PEVEN;
502: }
503: if (cflag&CSTOPB)
504: cfcr |= CFCR_STOPB;
505: outb(com+com_cfcr, cfcr);
506:
507: if (com_hasfifo & (1 << unit))
508: outb(com+com_fifo, FIFO_ENABLE | FIFO_TRIGGER_14);
509:
510: return(0);
511: }
512:
513: comstart(tp)
514: register struct tty *tp;
515: {
516: register com;
517: int s, unit, c;
518:
519: unit = UNIT(tp->t_dev);
520: com = com_addr[unit];
521: s = spltty();
522: if (tp->t_state & (TS_TIMEOUT|TS_TTSTOP))
523: goto out;
524: if (tp->t_outq.c_cc <= tp->t_lowat) {
525: if (tp->t_state&TS_ASLEEP) {
526: tp->t_state &= ~TS_ASLEEP;
527: wakeup((caddr_t)&tp->t_outq);
528: }
529: if (tp->t_wsel) {
530: selwakeup(tp->t_wsel, tp->t_state & TS_WCOLL);
531: tp->t_wsel = 0;
532: tp->t_state &= ~TS_WCOLL;
533: }
534: }
535: if (tp->t_outq.c_cc == 0)
536: goto out;
537: if (inb(com+com_lsr) & LSR_TXRDY) {
538: c = getc(&tp->t_outq);
539: tp->t_state |= TS_BUSY;
540: outb(com+com_data, c);
541: if (com_hasfifo & (1 << unit))
542: for (c = 1; c < 16 && tp->t_outq.c_cc; ++c)
543: outb(com+com_data, getc(&tp->t_outq));
544: }
545: out:
546: splx(s);
547: }
548:
549: /*
550: * Stop output on a line.
551: */
552: /*ARGSUSED*/
553: comstop(tp, flag)
554: register struct tty *tp;
555: {
556: register int s;
557:
558: s = spltty();
559: if (tp->t_state & TS_BUSY) {
560: if ((tp->t_state&TS_TTSTOP)==0)
561: tp->t_state |= TS_FLUSH;
562: }
563: splx(s);
564: }
565:
566: commctl(dev, bits, how)
567: dev_t dev;
568: int bits, how;
569: {
570: register com;
571: register int unit;
572: int s;
573:
574: unit = UNIT(dev);
575: com = com_addr[unit];
576: s = spltty();
577: switch (how) {
578:
579: case DMSET:
580: outb(com+com_mcr, bits | MCR_IENABLE);
581: break;
582:
583: case DMBIS:
584: outb(com+com_mcr, inb(com+com_mcr) | bits | MCR_IENABLE);
585: break;
586:
587: case DMBIC:
588: outb(com+com_mcr, inb(com+com_mcr) & ~bits | MCR_IENABLE);
589: break;
590:
591: case DMGET:
592: bits = inb(com+com_msr);
593: break;
594: }
595: (void) splx(s);
596: return(bits);
597: }
598:
599: /*
600: * Following are all routines needed for COM to act as console
601: */
602: #include "i386/i386/cons.h"
603:
604: comcnprobe(cp)
605: struct consdev *cp;
606: {
607: int unit;
608:
609: /* locate the major number */
610: for (commajor = 0; commajor < nchrdev; commajor++)
611: if (cdevsw[commajor].d_open == comopen)
612: break;
613:
614: /* XXX: ick */
615: unit = CONUNIT;
616: com_addr[CONUNIT] = CONADDR;
617:
618: /* make sure hardware exists? XXX */
619:
620: /* initialize required fields */
621: cp->cn_dev = makedev(commajor, unit);
622: cp->cn_tp = &com_tty[unit];
623: #ifdef COMCONSOLE
624: cp->cn_pri = CN_REMOTE; /* Force a serial port console */
625: #else
626: cp->cn_pri = CN_NORMAL;
627: #endif
628: }
629:
630: comcninit(cp)
631: struct consdev *cp;
632: {
633: int unit = UNIT(cp->cn_dev);
634:
635: cominit(unit, comdefaultrate);
636: comconsole = unit;
637: comconsinit = 1;
638: }
639:
640: cominit(unit, rate)
641: int unit, rate;
642: {
643: register int com;
644: int s;
645: short stat;
646:
647: #ifdef lint
648: stat = unit; if (stat) return;
649: #endif
650: com = com_addr[unit];
651: s = splhigh();
652: outb(com+com_cfcr, CFCR_DLAB);
653: rate = ttspeedtab(comdefaultrate, comspeedtab);
654: outb(com+com_data, rate & 0xFF);
655: outb(com+com_ier, rate >> 8);
656: outb(com+com_cfcr, CFCR_8BITS);
657: outb(com+com_ier, IER_ERXRDY | IER_ETXRDY);
658: outb(com+com_fifo, FIFO_ENABLE|FIFO_RCV_RST|FIFO_XMT_RST|FIFO_TRIGGER_14);
659: stat = inb(com+com_iir);
660: splx(s);
661: }
662:
663: comcngetc(dev)
664: {
665: register com = com_addr[UNIT(dev)];
666: short stat;
667: int c, s;
668:
669: #ifdef lint
670: stat = dev; if (stat) return(0);
671: #endif
672: s = splhigh();
673: while (((stat = inb(com+com_lsr)) & LSR_RXRDY) == 0)
674: ;
675: c = inb(com+com_data);
676: stat = inb(com+com_iir);
677: splx(s);
678: return(c);
679: }
680:
681: /*
682: * Console kernel output character routine.
683: */
684: comcnputc(dev, c)
685: dev_t dev;
686: register int c;
687: {
688: register com = com_addr[UNIT(dev)];
689: register int timo;
690: short stat;
691: int s = splhigh();
692:
693: #ifdef lint
694: stat = dev; if (stat) return;
695: #endif
696: #ifdef KGDB
697: if (dev != kgdb_dev)
698: #endif
699: if (comconsinit == 0) {
700: (void) cominit(UNIT(dev), comdefaultrate);
701: comconsinit = 1;
702: }
703: /* wait for any pending transmission to finish */
704: timo = 50000;
705: while (((stat = inb(com+com_lsr)) & LSR_TXRDY) == 0 && --timo)
706: ;
707: outb(com+com_data, c);
708: /* wait for this transmission to complete */
709: timo = 1500000;
710: while (((stat = inb(com+com_lsr)) & LSR_TXRDY) == 0 && --timo)
711: ;
712: /* clear any interrupts generated by this transmission */
713: stat = inb(com+com_iir);
714: splx(s);
715: }
716: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.