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