![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to rs.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / d / 286_KERNEL / USRSRC / io|
Return to rs.c CVS log | Up to [MW Coherent from dump] / coherent / d / 286_KERNEL / USRSRC / io |
1.1 root 1: /* (-lgl
2: * COHERENT Driver Kit Version 1.1.0
3: * Copyright (c) 1982, 1990 by Mark Williams Company.
4: * All rights reserved. May not be copied without permission.
5: -lgl) */
6: /*
7: * Raw Serial Device Driver.
8: *
9: * Provides fast, efficiently buffered serial i/o to COM1 & COM2.
10: * Supports an extreme subset of System V (termio) parameters.
11: * c_iflag: ISTRIP, IXON, IXANY, IGNBRK, INPCK, PARMRK, IGNPAR.
12: * c_oflag: OPOST, ONLCR, ONLRET, TAB3.
13: * c_cflag: *.
14: *
15: */
16:
17: #include <sys/coherent.h>
18: #include <sys/ins8250.h>
19: #include <sys/proc.h>
20: #include <sys/uproc.h>
21: #include <sys/con.h>
22: #include <sys/devices.h>
23: #include <sys/sched.h>
24: #include <sys/stat.h>
25: #include <termio.h>
26: #include <errno.h>
27:
28: #define COM1VEC 4 /* interrupt vector for COM1 */
29: #define COM2VEC 3 /* interrupt vector for COM2 */
30:
31: #define COM1PORT 0x3F8 /* i/o port address for COM1 */
32: #define COM2PORT 0x2F8 /* i/o port address for COM2 */
33:
34: #ifdef RS1
35: # define CFLAG RS1CFLAG
36: # define MAJ AL1_MAJOR /* major device for /dev/rs1 */
37: # define rscon rs1con /* configuration table for " */
38: # define rstty rs1tty
39: # define IVEC COM2VEC /* interrupt vector for rs1 */
40: # define PORT COM2PORT /* i/o port address for rs1 */
41: #else
42: # define CFLAG RS0CFLAG
43: # define MAJ AL0_MAJOR /* major device for /dev/rs0 */
44: # define rscon rs0con /* configuration table for " */
45: # define rstty rs0tty
46: # define IVEC COM1VEC /* interrupt vector for rs0 */
47: # define PORT COM1PORT /* i/o port address for rs0 */
48: #endif
49:
50: #define CTRLS '\023'
51: #define CTRLQ '\021'
52:
53: /*
54: * Functions.
55: */
56:
57: int rsload();
58: int rsunload();
59: int rsopen();
60: int rsclose();
61: int rsread();
62: int rswrite();
63: int rsioctl();
64: int rspoll();
65: int nulldev();
66: int nonedev();
67:
68: int rsintr();
69: int rsparam();
70:
71: /*
72: * Configuration table.
73: */
74:
75: CON rscon ={
76: DFCHR|DFPOL, /* Flags */
77: MAJ, /* Major index */
78: rsopen, /* Open */
79: rsclose, /* Close */
80: nulldev, /* Block */
81: rsread, /* Read */
82: rswrite, /* Write */
83: rsioctl, /* Ioctl */
84: nulldev, /* Powerfail */
85: nulldev, /* Timeout */
86: rsload, /* Load */
87: rsunload, /* Unload */
88: rspoll /* Poll */
89: };
90:
91: /*
92: * Terminal structure.
93: */
94:
95: #define RAWSZ (2048-1)
96: #define OUTSZ (2048-1)
97:
98: #define NRAWC ((rsrawq.rq_ix - rsrawq.rq_ox) & RAWSZ)
99: #define NOUTC ((rsoutq.rq_ix - rsoutq.rq_ox) & OUTSZ)
100:
101: #define TTSTOP 00001
102: #define TTSBRK 00002
103: #define CARRIER 00004
104:
105: typedef
106: struct rawtty_s {
107: unsigned rt_state; /* terminal state */
108: int rt_group; /* controlling process group */
109: unsigned rt_ticks; /* send break 1/10 sec counter */
110: unsigned rt_iflag; /* termio input flags */
111: unsigned rt_oflag; /* termio output flags */
112: unsigned rt_cflag; /* termio control flags */
113: unsigned char rt_col; /* current output column */
114: unsigned char rt_refc; /* # procs accessing the port */
115: unsigned char rt_irefc; /* # procs waiting for input */
116: unsigned char rt_orefc; /* # procs waitint for output */
117: unsigned char rt_crefc; /* # procs waiting for carrier */
118: unsigned char rt_drefc; /* # procs waiting for drain */
119: event_t rt_ipolls; /* Procs polling on input queue */
120: event_t rt_opolls; /* Procs polling on output que */
121: } RAWTTY;
122:
123: typedef
124: struct iring_s {
125: unsigned short rq_mask;
126: unsigned short rq_ix;
127: unsigned short rq_ox;
128: unsigned char rq_cc[RAWSZ+1];
129: } IRING;
130:
131: typedef
132: struct oring_s {
133: unsigned short rq_mask;
134: unsigned short rq_ix;
135: unsigned short rq_ox;
136: unsigned char rq_cc[OUTSZ+1];
137: } ORING;
138:
139: /*
140: * Local variables.
141: */
142: unsigned CFLAG = CLOCAL | CREAD | B1200 | CS8 | HUPCL;
143: RAWTTY rstty;
144: static ORING rsoutq;
145: static IRING rsrawq;
146: static TIM rstim;
147:
148: /*
149: * Time constant table.
150: * Indexed by ioctl baud rate.
151: */
152: static
153: int timeconst[] = {
154: 0, /* 0 */
155: 2304, /* 50 */
156: 1536, /* 75 */
157: 1047, /* 110 */
158: 857, /* 134.5 */
159: 768, /* 150 */
160: 576, /* 200 */
161: 384, /* 300 */
162: 192, /* 600 */
163: 96, /* 1200 */
164: 64, /* 1800 */
165: 48, /* 2400 */
166: 24, /* 4800 */
167: 12, /* 9600 */
168: 6, /* 19200/EXTA */
169: 6 /* 19200/EXTB */
170: };
171:
172: /*
173: * Rsload() -- Raw Serial Load Routine.
174: *
175: * Action: Define terminal parameters.
176: * Initialize terminal hardware.
177: * If serial port exists, seize its interrupt vector.
178: *
179: * Return: None.
180: */
181:
182: static
183: rsload()
184: {
185: /*
186: * Initialize terminal parameters.
187: */
188: rsoutq.rq_mask = OUTSZ;
189: rsrawq.rq_mask = RAWSZ;
190:
191: /*
192: * Initialize terminal hardware.
193: */
194: rsparam();
195:
196: /*
197: * If serial port exists, initialize interrupt vector.
198: */
199: if ( inb(PORT+IER) == 0 ) {
200: setivec( IVEC, rsintr);
201: rscycle();
202: }
203: }
204:
205: /*
206: * Rsunload() -- Raw Serial unload Routine.
207: */
208:
209: static
210: rsunload()
211: {
212: timeout( &rstim, 0, NULL, 0 ); /* cancel timed function */
213: clrivec( IVEC ); /* release interrupt vector */
214: outb(PORT+IER, 0); /* disable port interrupts */
215: outb(PORT+MCR, MC_OUT2); /* hangup port */
216: }
217:
218: /*
219: * Rsopen -- Open Routine.
220: *
221: * Input: dev = device to open.
222: * If high bit (0x80) set in minor, modem control is requested.
223: *
224: * Action: Validate minor device.
225: * Increment reference count.
226: * If first reference and parameters are not initialized,
227: * set default parameters and initialize hardware.
228: *
229: * Return: None.
230: */
231:
232: static
233: rsopen( dev, mode )
234:
235: dev_t dev;
236:
237: {
238: register PROC *pp = SELF;
239:
240: /*
241: * Validate minor device.
242: */
243: if (minor(dev) & ~0x80) {
244: u.u_error = ENODEV;
245: return;
246: }
247:
248: /*
249: * Validate hardware.
250: */
251: if (inb(PORT+IER) & ~(IE_RxI|IE_TxI|IE_LSI)) {
252: u.u_error = ENXIO;
253: return;
254: }
255:
256: /*
257: * Ensure controlling terminal and group fields initialized.
258: */
259: if (pp->p_ttdev == NODEV)
260: pp->p_ttdev = dev;
261: if (pp->p_group == 0)
262: pp->p_group = pp->p_pid;
263:
264: /*
265: * Check for first open.
266: */
267: if (++rstty.rt_refc == 1) {
268:
269: if (pp->p_group == pp->p_pid)
270: rstty.rt_group = pp->p_group;
271:
272: if ((rstty.rt_cflag & CBAUD) == B0) {
273:
274: /*
275: * Define terminal parameters.
276: */
277: rstty.rt_state = 0;
278: rstty.rt_col = 0;
279: rstty.rt_iflag = ISTRIP | IXON;
280: rstty.rt_oflag = OPOST | ONLCR | TAB3;
281: rstty.rt_cflag = CFLAG;
282: if ( minor(dev) & 0x80 )
283: rstty.rt_cflag &= ~CLOCAL;
284:
285: /*
286: * Initialize terminal hardware.
287: */
288: rsparam();
289: }
290:
291: /*
292: * Discard input data.
293: */
294: rsrawq.rq_ox = rsrawq.rq_ix;
295: }
296:
297: /*
298: * If modem control is requested, check carrier.
299: */
300: if ( minor(dev) & 0x80 ) {
301:
302: /*
303: * Delay until carrier is present.
304: */
305: while ( (rstty.rt_state & CARRIER) == 0 ) {
306:
307: /*
308: * Sleep on carrier.
309: */
310: ++rstty.rt_crefc;
311: sleep( &rstty.rt_crefc,
312: CVTTOUT, IVTTOUT, SVTTOUT);
313: --rstty.rt_crefc;
314:
315: /*
316: * Abort if non-ignored signal is received.
317: */
318: if (SELF->p_ssig && nondsig()) {
319:
320: if (--rstty.rt_refc == 0) {
321: rstty.rt_group = 0;
322: rstty.rt_cflag = 0;
323: rsparam();
324: }
325: u.u_error = EINTR;
326: return;
327: }
328: }
329: }
330: }
331:
332: /*
333: * Rsclose -- Close Routine.
334: *
335: * Action: Decrement reference count.
336: * If serial port is no longer referenced,
337: * and the hangup on last close bit is set in rt_cflag,
338: * clear terminal parameters, and initialize hardware.
339: *
340: * Return: None.
341: *
342: * Note: This routine does not wait for the output queue to empty.
343: */
344:
345: static
346: rsclose( dev )
347:
348: dev_t dev;
349:
350: {
351: /*
352: * Check for last close and hangup on close.
353: */
354: if ((rstty.rt_refc == 1) && (rstty.rt_cflag & HUPCL)) {
355:
356: /*
357: * Wait for output to drain.
358: */
359: while ( rsoutq.rq_ox != rsoutq.rq_ix ) {
360:
361: ++rstty.rt_drefc;
362: sleep( &rstty.rt_drefc, CVTTOUT, IVTTOUT, SVTTOUT );
363: --rstty.rt_drefc;
364:
365: if (rstty.rt_refc != 1) {
366: rstty.rt_refc--;
367: return;
368: }
369:
370: if (SELF->p_ssig && nondsig())
371: break;
372: }
373:
374: /*
375: * Initialize terminal hardware.
376: */
377: rstty.rt_group = 0;
378: rstty.rt_cflag = 0;
379: rsparam();
380:
381: /*
382: * Flush input and output queues.
383: */
384: rsrawq.rq_ix =
385: rsrawq.rq_ox =
386: rsoutq.rq_ox =
387: rsoutq.rq_ix = 0;
388: }
389: --rstty.rt_refc;
390: }
391:
392: /*
393: * Rsread -- Read Routine.
394: *
395: * Input: iop = pointer to structure containing i/o parameters.
396: *
397: * Action: Attempt to read data from input buffer until at least
398: * one character has been read, or a signal is received
399: * by the current process.
400: * Update the parameters in the io structure.
401: * If a signal is received, set errno to EINTR.
402: *
403: * Return: None.
404: */
405:
406: static
407: rsread( dev, iop )
408:
409: dev_t dev;
410: register IO *iop;
411:
412: {
413: register int sioc;
414:
415: /*
416: * Remember original char count.
417: */
418: sioc = iop->io_ioc;
419:
420: do {
421: /*
422: * Transfer data until done or input buffer empty.
423: */
424: rsin( &rsrawq, iop );
425:
426: /*
427: * Return if some data was transferred.
428: */
429: if (sioc != iop->io_ioc)
430: return;
431:
432: /*
433: * Non-blocking reads.
434: */
435: if ( iop->io_flag & IONDLY ) {
436: u.u_error = EAGAIN;
437: return;
438: }
439:
440: /*
441: * Sleep waiting for a signal or input data.
442: */
443: ++rstty.rt_irefc;
444: sleep( &rstty.rt_irefc, CVTTOUT, IVTTOUT, SVTTOUT );
445: --rstty.rt_irefc;
446:
447: /*
448: * Abort if a non-ignored signal was received.
449: */
450: if (SELF->p_ssig && nondsig()) {
451: u.u_error = EINTR;
452: return;
453: }
454:
455: } while (1);
456: }
457:
458: /*
459: * Rswrite -- Write Routine.
460: */
461:
462: static
463: rswrite( dev, iop )
464:
465: dev_t dev;
466: register IO *iop;
467:
468: {
469: register int n;
470:
471: /*
472: * Non-blocking write.
473: */
474: if ( iop->io_flag & IONDLY ) {
475:
476: /*
477: * Calculate free slots.
478: */
479: n = rsoutq.rq_mask - rsoutq.rq_ix + rsoutq.rq_ox;
480: n &= rsoutq.rq_mask;
481:
482: /*
483: * Insufficient space.
484: */
485: if ( n <= iop->io_ioc ) {
486: u.u_error = EAGAIN;
487: return;
488: }
489: }
490:
491: do {
492: /*
493: * Transfer data until done or output queue full.
494: */
495: rsout( &rsoutq, iop );
496:
497: /*
498: * Make sure the transmitter is operating.
499: */
500: rsstart();
501:
502: /*
503: * Return if all data was transferred.
504: */
505: if ( iop->io_ioc == 0 )
506: return;
507:
508: /*
509: * Sleep waiting for a signal or room in the output queue.
510: */
511: ++rstty.rt_orefc;
512: sleep( &rstty.rt_orefc, CVTTOUT, IVTTOUT, SVTTOUT );
513: --rstty.rt_orefc;
514:
515: /*
516: * Abort if a non-ignored signal was received.
517: */
518: if ( SELF->p_ssig && nondsig() ) {
519: u.u_error = EINTR;
520: return;
521: }
522:
523: } while (1);
524: }
525:
526: /*
527: * Rspoll -- Polling Routine.
528: */
529: static int
530: rspoll( dev, ev, msec )
531: dev_t dev;
532: register int ev;
533: int msec;
534: {
535: /*
536: * No priority reports.
537: */
538: ev &= ~POLLPRI;
539:
540: /*
541: * Input poll with empty input ring.
542: */
543: if ( (ev & POLLIN) && (rsrawq.rq_ix == rsrawq.rq_ox) ) {
544:
545: /*
546: * Blocking input poll.
547: */
548: if ( msec != 0 )
549: pollopen( &rstty.rt_ipolls );
550:
551: /*
552: * Second look and clear input report.
553: */
554: if ( rsrawq.rq_ix == rsrawq.rq_ox )
555: ev &= ~POLLIN;
556: }
557:
558: /*
559: * Output poll with non-empty output ring.
560: */
561: if ( (ev & POLLOUT) && (rsoutq.rq_ix != rsrawq.rq_ox) ) {
562:
563: /*
564: * Blocking output poll.
565: */
566: if ( msec != 0 )
567: pollopen( &rstty.rt_opolls );
568:
569: /*
570: * Second look and clear output report.
571: */
572: if ( rsoutq.rq_ix != rsoutq.rq_ox )
573: ev &= ~POLLOUT;
574: }
575:
576: return ev;
577: }
578:
579: /*
580: * Cyclic [1 sec] Routine.
581: */
582: static
583: rscycle()
584: {
585: register PROC *pp;
586: register int b;
587:
588: /*
589: * Check for carrier transitions.
590: */
591: if ( inb( PORT + MSR ) & MS_RLSD ) {
592:
593: /*
594: * Have carrier. Wake processes waiting for carrier.
595: */
596: rstty.rt_state |= CARRIER;
597:
598: if ( rstty.rt_crefc )
599: wakeup( &rstty.rt_crefc );
600: }
601: else if ((rstty.rt_state & CARRIER) && (rstty.rt_cflag&CLOCAL) == 0) {
602:
603: /*
604: * Lost carrier. Signal attached processes.
605: */
606: rstty.rt_state &= ~CARRIER;
607:
608: if (rstty.rt_refc && (b = rstty.rt_group))
609: for (pp=procq.p_nforw; pp != &procq; pp=pp->p_nforw)
610: if ( pp->p_group == b )
611: sendsig( SIGHUP, pp );
612: }
613:
614: /*
615: * Wakeup processes waiting to read if input data present.
616: */
617: if ( rsrawq.rq_ix != rsrawq.rq_ox ) {
618: if ( rstty.rt_irefc )
619: wakeup( &rstty.rt_irefc );
620: if ( rstty.rt_ipolls.e_procp )
621: pollwake( &rstty.rt_ipolls );
622: }
623:
624: /*
625: * Check for break being sent.
626: */
627: if ( rstty.rt_ticks != 0 ) {
628:
629: if ( --rstty.rt_ticks == 0 ) {
630:
631: b = inb( PORT + LCR );
632: outb( PORT + LCR, b & ~LC_SBRK );
633: rstty.rt_state &= ~TTSBRK;
634: }
635: }
636:
637: /*
638: * Can check output if not sending break.
639: */
640: if ( rstty.rt_ticks == 0 ) {
641:
642: /*
643: * Restart output if necessary.
644: */
645: if ( rsoutq.rq_ox != rsoutq.rq_ix )
646: rsstart();
647:
648: /*
649: * Wakeup processes waiting for drain if output queue empty.
650: */
651: if ( rstty.rt_drefc ) {
652: if ( rsoutq.rq_ix == rsoutq.rq_ox )
653: wakeup( &rstty.rt_drefc );
654: }
655:
656: /*
657: * Wakeup processes waiting to write if 512 slots are free.
658: */
659: else if ( NOUTC < OUTSZ-512 ) {
660: if ( rstty.rt_orefc )
661: wakeup( &rstty.rt_orefc );
662: if ( rstty.rt_opolls.e_procp )
663: pollwake( &rstty.rt_opolls );
664: }
665: }
666:
667: timeout( &rstim, HZ/10, rscycle, 0 );
668: }
669:
670: /*
671: * Rsintr -- Serial Interrupt Handler.
672: *
673: * Action: Process all pending interrupt service requests
674: * on the serial port.
675: *
676: * Return: None.
677: *
678: * Notes: This routine must loop until all requests are serviced
679: * because of the edge sensitive nature of the programmable
680: * interrupt controller.
681: */
682:
683: static
684: rsintr()
685: {
686: register int b;
687:
688: /*
689: * Service serial port interrupt requests, highest to lowest priority.
690: */
691: rescan:
692: b = inb( PORT + IIR );
693:
694: switch ( b ) {
695:
696: case LS_INTR:
697: /*
698: * Get line status (clear interrupt).
699: */
700: b = inb( PORT + LSR );
701:
702: /*
703: * Check for received break.
704: */
705: if (b & LS_BREAK) {
706:
707: /*
708: * Read the break char ('\0').
709: */
710: rsrawq.rq_cc[ rsrawq.rq_ix ] = inb( PORT + DREG );
711:
712: /*
713: * Clear output stops.
714: */
715: rstty.rt_state &= ~TTSTOP;
716:
717: /*
718: * Update input index if not ignoring break.
719: */
720: if ((rstty.rt_iflag & IGNBRK) == 0) {
721: rsrawq.rq_ix ++;
722: rsrawq.rq_ix &= RAWSZ;
723: }
724: }
725:
726: /*
727: * Special handling if frame/parity error and checking enabled.
728: */
729: if ((b & (LS_FRAME|LS_PARITY)) && (rstty.rt_iflag & INPCK)) {
730:
731: /*
732: * Ignore next input char if IGNPAR set.
733: */
734: if (rstty.rt_iflag & IGNPAR)
735: inb( PORT + DREG );
736: /*
737: * Change next input char into 0377,0,ch if PARMRK set.
738: */
739: else if (rstty.rt_iflag & PARMRK) {
740:
741: b = rsrawq.rq_ix;
742: rsrawq.rq_cc[ b++ ] = 0377;
743: b &= RAWSZ;
744: rsrawq.rq_cc[ b++ ] = '\0';
745: b &= RAWSZ;
746: rsrawq.rq_cc[ b++ ] = inb( PORT + DREG );
747: b &= RAWSZ;
748: rsrawq.rq_ix = b;
749: }
750:
751: /*
752: * Otherwise change next input char into null.
753: */
754: else {
755: inb( PORT + DREG );
756: rsrawq.rq_cc[ rsrawq.rq_ix++ ] = '\0';
757: rsrawq.rq_ix &= RAWSZ;
758: }
759: }
760: goto rescan;
761:
762: case Rx_INTR:
763: /*
764: * Read character from receive buffer.
765: */
766: b = inb( PORT + DREG );
767:
768: /*
769: * Discard high bit if ISTRIP set.
770: */
771: if ( rstty.rt_iflag & ISTRIP )
772: b &= 0177;
773:
774: /*
775: * Check for output flow control if IXON set.
776: */
777: if ( rstty.rt_iflag & IXON ) {
778:
779: /*
780: * Stop output if Ctl-S.
781: */
782: if ( b == CTRLS ) {
783: rstty.rt_state |= TTSTOP;
784: goto rescan;
785: }
786:
787: /*
788: * Resume output if Ctl-Q.
789: */
790: if ( b == CTRLQ ) {
791: rstty.rt_state &= ~TTSTOP;
792: goto rescan;
793: }
794:
795: /*
796: * Enable output if IXANY set.
797: */
798: if ( rstty.rt_iflag & IXANY )
799: rstty.rt_state &= ~TTSTOP;
800: }
801:
802: /*
803: * Save the character in the input queue.
804: */
805: rsrawq.rq_cc[ rsrawq.rq_ix++ ] = b;
806: rsrawq.rq_ix &= RAWSZ;
807:
808: /*
809: * Save again if 0377 and parity marking enabled.
810: */
811: if ((b == 0377)
812: && ((rstty.rt_iflag & (INPCK|PARMRK)) == (INPCK|PARMRK))) {
813:
814: rsrawq.rq_cc[ rsrawq.rq_ix++ ] = b;
815: rsrawq.rq_ix &= RAWSZ;
816: }
817:
818: goto rescan;
819:
820: case Tx_INTR:
821: rsstart();
822: goto rescan;
823: }
824: }
825:
826: /*
827: * Rsstart()
828: *
829: * Action: While output data is available, and the transmitter buffer
830: * is empty, transfer one character from the output queue to the
831: * transmit buffer.
832: *
833: * Return: None.
834: */
835:
836: static
837: rsstart()
838: {
839: register int b;
840: register int s;
841:
842: /*
843: * Can't transmit if output stopped or sending break.
844: */
845: if ( rstty.rt_state & (TTSTOP|TTSBRK) )
846: return;
847:
848: /*
849: * Can't transmit if modem control enabled without CTS present.
850: */
851: if ( (rstty.rt_cflag & CLOCAL) == 0 )
852: if ( (inb(PORT+MSR) & MS_CTS) == 0 )
853: return;
854:
855: /*
856: * Disable interrupts to avoid critical race.
857: */
858: s = sphi();
859:
860: /*
861: * Can transmit if output data available and transmit buffer empty.
862: */
863: if ( (rsoutq.rq_ix != rsoutq.rq_ox)
864: && (inb(PORT+LSR) & LS_TxRDY) ) {
865:
866: /*
867: * Get next char from output queue.
868: */
869: b = rsoutq.rq_cc [ rsoutq.rq_ox ];
870:
871: if (rstty.rt_oflag & OPOST) {
872:
873: /*
874: * Printable characters increment the column.
875: */
876: if (b >= ' ') {
877: rstty.rt_col++;
878: }
879: /*
880: * Carriage return resets the column.
881: */
882: else if (b == '\r') {
883: rstty.rt_col = 0;
884: if (rstty.rt_oflag & OCRNL)
885: b = '\n';
886: }
887: /*
888: * New-line may also generate a carriage return.
889: */
890: else if (b == '\n') {
891: if (rstty.rt_oflag & ONLCR) {
892: if (rstty.rt_col) {
893: rstty.rt_col = 0;
894: rsoutq.rq_ox--;
895: b = '\r';
896: }
897: }
898: else if (rstty.rt_oflag & ONLRET)
899: rstty.rt_col = 0;
900: }
901: /*
902: * Backspace decrements the column.
903: */
904: else if (b == '\b') {
905: if (rstty.rt_col)
906: --rstty.rt_col;
907: }
908: /*
909: * Tabs may generate spaces, always move to tab stop.
910: */
911: else if (b == '\t') {
912: if ((rstty.rt_oflag & TABDLY) == TAB3) {
913: b = ' ';
914: if (++rstty.rt_col & 7)
915: rsoutq.rq_ox--;
916: }
917: else {
918: rstty.rt_col |= 7;
919: rstty.rt_col++;
920: }
921: }
922: }
923: rsoutq.rq_ox++;
924: rsoutq.rq_ox &= OUTSZ;
925:
926: /*
927: * Transmit next char.
928: */
929: outb( PORT+DREG, b );
930: }
931:
932: spl(s);
933: }
934:
935: /*
936: * Ioctl Routine.
937: */
938:
939: static
940: rsioctl( dev, com, vec )
941:
942: dev_t dev;
943: int com;
944: struct termio *vec;
945:
946: {
947: register int b;
948: struct termio tb;
949:
950: switch (com) {
951:
952: case TCSETAW: /* Set attributes after waiting for output to clear */
953: case TCSETAF: /* ditto, but also flush input queue */
954: case TCSBRK: /* wait for output to clear, send break */
955:
956: /*
957: * Delay until output queue is empty.
958: */
959: while ( rsoutq.rq_ox != rsoutq.rq_ix ) {
960:
961: /*
962: * Sleep waiting for empty output queue.
963: */
964: ++rstty.rt_drefc;
965: sleep( &rstty.rt_drefc, CVTTOUT, IVTTOUT, SVTTOUT);
966: --rstty.rt_drefc;
967:
968: /*
969: * Abort if a non-ignored signal was received.
970: */
971: if ( SELF->p_ssig && nondsig() ) {
972: u.u_error = EINTR;
973: return;
974: }
975: }
976:
977: if ( com == TCSBRK ) {
978:
979: b = inb( PORT + LCR );
980:
981: if ( vec == 0 ) {
982: rstty.rt_ticks = 3; /* 0.2 to 0.3 sec */
983: rstty.rt_state |= TTSBRK;
984: b |= LC_SBRK;
985: }
986: else {
987: rstty.rt_ticks = 0;
988: rstty.rt_state &= ~TTSBRK;
989: b &= ~LC_SBRK;
990: }
991:
992: outb( PORT + LCR, b );
993: return;
994: }
995: /* no break */
996:
997: case TCSETA:
998: /*
999: * Get new terminal attributes.
1000: */
1001: ukcopy( vec, &tb, sizeof(tb) );
1002: if ( u.u_error )
1003: return;
1004:
1005: /*
1006: * Set terminal attributes and hardware.
1007: */
1008: rstty.rt_iflag = tb.c_iflag;
1009: rstty.rt_oflag = tb.c_oflag;
1010: if (rstty.rt_cflag != tb.c_cflag) {
1011: rstty.rt_cflag = tb.c_cflag;
1012: rsparam();
1013: }
1014:
1015: if ((rstty.rt_iflag & IXON) == 0)
1016: rstty.rt_state &= ~TTSTOP;
1017:
1018: /*
1019: * Flush input queue if command was TCSETAF.
1020: */
1021: if ( com == TCSETAF )
1022: rsrawq.rq_ox = rsrawq.rq_ix;
1023: break;
1024:
1025: case TCGETA: /* Get terminal attributes */
1026:
1027: memset( &tb, 0, sizeof(tb) );
1028: tb.c_cflag = rstty.rt_cflag;
1029: tb.c_iflag = rstty.rt_iflag;
1030: tb.c_oflag = rstty.rt_oflag;
1031:
1032: /*
1033: * Transfer terminal attributes to user space.
1034: */
1035: kucopy( &tb, vec, sizeof(tb) );
1036: break;
1037:
1038: case TCFLSH:
1039: switch ((int) vec) {
1040: case 0:
1041: /* flush input queue */
1042: rsrawq.rq_ox = rsrawq.rq_ix;
1043: break;
1044: case 1:
1045: /* flush output queue */
1046: rsoutq.rq_ox = rsoutq.rq_ix;
1047: break;
1048: case 2:
1049: /* flush both input and output queues */
1050: rsrawq.rq_ox = rsrawq.rq_ix;
1051: rsoutq.rq_ox = rsoutq.rq_ix;
1052: break;
1053: default:
1054: u.u_error = EINVAL;
1055: }
1056: break;
1057:
1058: case TCXONC:
1059: switch ( (int) vec ) {
1060: case 0:
1061: /* stop output */
1062: rstty.rt_state |= TTSTOP;
1063: break;
1064: case 1:
1065: /* restart output */
1066: rstty.rt_state &= ~TTSTOP;
1067: rsstart();
1068: break;
1069: default:
1070: u.u_error = EINVAL;
1071: }
1072: break;
1073:
1074: default:
1075: u.u_error = EINVAL;
1076: }
1077: }
1078:
1079: /*
1080: * Rsparam -- Setup hardware parameters.
1081: */
1082:
1083: static
1084: rsparam()
1085: {
1086: register int b;
1087: register int s;
1088:
1089: /*
1090: * Disable interrupts.
1091: */
1092: s = sphi();
1093:
1094: /*
1095: * Assert required modem control lines (DTR, RTS).
1096: */
1097: if ((rstty.rt_cflag & CBAUD) == B0)
1098: outb( PORT+MCR, MC_OUT2 );
1099: else if ((rstty.rt_refc == 0) && (rstty.rt_cflag & HUPCL))
1100: outb( PORT+MCR, MC_OUT2 );
1101: else
1102: outb( PORT+MCR, MC_OUT2+MC_DTR+MC_RTS );
1103:
1104: /*
1105: * Program baud rate.
1106: */
1107: if (b = timeconst[ rstty.rt_cflag & CBAUD ]) {
1108: outb( PORT+LCR, LC_DLAB );
1109: outb( PORT+DLL, b );
1110: outb( PORT+DLH, b >> 8 );
1111: }
1112:
1113: /*
1114: * Program character size, parity, and stop bits.
1115: */
1116: switch (rstty.rt_cflag & CSIZE) {
1117: case CS5: b = LC_CS5; break;
1118: case CS6: b = LC_CS6; break;
1119: case CS7: b = LC_CS7; break;
1120: case CS8: b = LC_CS8; break;
1121: }
1122:
1123: switch (rstty.rt_cflag & (PARENB|PARODD)) {
1124: case PARENB: b |= LC_PARENB|LC_PAREVEN; break;
1125: case PARENB|PARODD: b |= LC_PARENB; break;
1126: }
1127:
1128: if (rstty.rt_cflag & CSTOPB)
1129: b |= LC_STOPB;
1130:
1131: if (rstty.rt_state & TTSBRK)
1132: b |= LC_SBRK;
1133:
1134: outb( PORT+LCR, b );
1135:
1136: /*
1137: * Enable desired interrupts.
1138: */
1139: b = 0;
1140: if (rstty.rt_cflag & CBAUD) {
1141: b = IE_TxI | IE_LSI;
1142: if (rstty.rt_cflag & CREAD)
1143: b |= IE_RxI;
1144: }
1145: outb( PORT+IER, b );
1146:
1147: /*
1148: * Enable interrupts.
1149: */
1150: spl( s );
1151: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.