![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to chario.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / Gnu-Mach / device|
Return to chario.c CVS log | Up to [GnuMach] / Gnu-Mach / device |
1.1 root 1: /*
2: * Mach Operating System
3: * Copyright (c) 1993-1988 Carnegie Mellon University
4: * All Rights Reserved.
5: *
6: * Permission to use, copy, modify and distribute this software and its
7: * documentation is hereby granted, provided that both the copyright
8: * notice and this permission notice appear in all copies of the
9: * software, derivative works or modified versions, and any portions
10: * thereof, and that both notices appear in supporting documentation.
11: *
12: * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
13: * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
14: * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
15: *
16: * Carnegie Mellon requests users of this software to return to
17: *
18: * Software Distribution Coordinator or [email protected]
19: * School of Computer Science
20: * Carnegie Mellon University
21: * Pittsburgh PA 15213-3890
22: *
23: * any improvements or extensions that they make and grant Carnegie Mellon
24: * the rights to redistribute these changes.
25: */
26: /*
27: * Author: David B. Golub, Carnegie Mellon University
28: * Date: 8/88
29: *
30: * TTY io.
31: * Compatibility with old TTY device drivers.
32: */
33:
34: #include <mach/kern_return.h>
35: #include <mach/mig_errors.h>
36: #include <mach/vm_param.h>
37: #include <machine/machspl.h> /* spl definitions */
38:
39: #include <ipc/ipc_port.h>
40:
41: #include <kern/lock.h>
42: #include <kern/queue.h>
43:
44: #include <vm/vm_map.h>
45: #include <vm/vm_kern.h>
46:
47: #include <device/device_types.h>
48: #include <device/io_req.h>
49: #include <device/ds_routines.h>
50: #include "device_reply.h"
51:
52: #include <device/tty.h>
53:
54: /* If you change these, check that tty_outq_size and tty_inq_size
55: * is greater than largest tthiwat entry.
56: */
57: short tthiwat[16] =
58: { 100,100,100,100,100,100,100,200,200,400,400,400,650,650,1300,2000 };
59: short ttlowat[16] =
60: { 30, 30, 30, 30, 30, 30, 30, 50, 50,120,120,120,125,125, 125, 125 };
61:
62: /*
63: * forward declarations
64: */
65: void queue_delayed_reply(
66: queue_t, io_req_t, boolean_t (*)(io_req_t));
67: void tty_output(struct tty *);
68: void tty_flush(struct tty *, int);
69: boolean_t char_open_done(io_req_t);
70: boolean_t char_read_done(io_req_t);
71: boolean_t char_write_done(io_req_t);
72:
73: /*
74: * Fake 'line discipline' switch for the benefit of old code
75: * that wants to call through it.
76: */
77: struct ldisc_switch linesw[] = {
78: {
79: char_read,
80: char_write,
81: ttyinput,
82: ttymodem,
83: tty_output
84: }
85: };
86:
87: /*
88: * Sizes for input and output circular buffers.
89: */
90: int tty_inq_size = 4096; /* big nuf */
91: int tty_outq_size = 2048; /* Must be bigger that tthiwat */
92: int pdma_default = 1; /* turn pseudo dma on by default */
93:
94: /*
95: * compute pseudo-dma tables
96: */
97:
98: int pdma_timeouts[NSPEEDS]; /* how many ticks in timeout */
99: int pdma_water_mark[NSPEEDS];
100:
101:
102: void chario_init(void)
103: {
104: /* the basic idea with the timeouts is two allow enough
105: time for a character to show up if data is coming in at full data rate
106: plus a little slack. 2 ticks is considered slack
107: Below 300 baud we just glob a character at a time */
108: #define _PR(x) ((hz/x) + 2)
109:
110: int i;
111:
112: for (i = B0; i < B300; i++)
113: pdma_timeouts[i] = 0;
114:
115: pdma_timeouts[B300] = _PR(30);
116: pdma_timeouts[B600] = _PR(60);
117: pdma_timeouts[B1200] = _PR(120);
118: pdma_timeouts[B1800] = _PR(180);
119: pdma_timeouts[B2400] = _PR(240);
120: pdma_timeouts[B4800] = _PR(480);
121: pdma_timeouts[B9600] = _PR(960);
122: pdma_timeouts[EXTA] = _PR(1440); /* >14400 baud */
123: pdma_timeouts[EXTB] = _PR(1920); /* >19200 baud */
124:
125: for (i = B0; i < B300; i++)
126: pdma_water_mark[i] = 0;
127:
128: /* for the slow speeds, we try to buffer 0.02 of the baud rate
129: (20% of the character rate). For the faster lines,
130: we try to buffer 1/2 the input queue size */
131:
132: #undef _PR
133: #define _PR(x) (0.20 * x)
134:
135: pdma_water_mark[B300] = _PR(120);
136: pdma_water_mark[B600] = _PR(120);
137: pdma_water_mark[B1200] = _PR(120);
138: pdma_water_mark[B1800] = _PR(180);
139: pdma_water_mark[B2400] = _PR(240);
140: pdma_water_mark[B4800] = _PR(480);
141: i = tty_inq_size/2;
142: pdma_water_mark[B9600] = i;
143: pdma_water_mark[EXTA] = i; /* >14400 baud */
144: pdma_water_mark[EXTB] = i; /* >19200 baud */
145:
146: return;
147: }
148:
149: /*
150: * Open TTY, waiting for CARR_ON.
151: * No locks may be held.
152: * May run on any CPU.
153: */
154: io_return_t char_open(
155: int dev,
156: struct tty * tp,
157: dev_mode_t mode,
158: io_req_t ior)
159: {
160: spl_t s;
161: io_return_t rc = D_SUCCESS;
162:
163: s = spltty();
164: simple_lock(&tp->t_lock);
165:
166: tp->t_dev = dev;
167:
168: if (tp->t_mctl)
169: (*tp->t_mctl)(tp, TM_DTR, DMSET);
170:
171: if (pdma_default)
172: tp->t_state |= TS_MIN;
173:
174: if ((tp->t_state & TS_CARR_ON) == 0) {
175: /*
176: * No carrier.
177: */
178: if (mode & D_NODELAY) {
179: tp->t_state |= TS_ONDELAY;
180: }
181: else {
182: /*
183: * Don`t return from open until carrier detected.
184: */
185: tp->t_state |= TS_WOPEN;
186:
187: ior->io_dev_ptr = (char *)tp;
188:
189: queue_delayed_reply(&tp->t_delayed_open, ior, char_open_done);
190: rc = D_IO_QUEUED;
191: goto out;
192: }
193: }
194: tp->t_state |= TS_ISOPEN;
195: if (tp->t_mctl)
196: (*tp->t_mctl)(tp, TM_RTS, DMBIS);
197: out:
198: simple_unlock(&tp->t_lock);
199: splx(s);
200: return rc;
201: }
202:
203: /*
204: * Retry wait for CARR_ON for open.
205: * No locks may be held.
206: * May run on any CPU.
207: */
208: boolean_t char_open_done(
209: io_req_t ior)
210: {
211: register struct tty *tp = (struct tty *)ior->io_dev_ptr;
212: spl_t s = spltty();
213:
214: simple_lock(&tp->t_lock);
215: if ((tp->t_state & TS_ISOPEN) == 0) {
216: queue_delayed_reply(&tp->t_delayed_open, ior, char_open_done);
217: simple_unlock(&tp->t_lock);
218: splx(s);
219: return FALSE;
220: }
221:
222: tp->t_state |= TS_ISOPEN;
223: tp->t_state &= ~TS_WOPEN;
224:
225: if (tp->t_mctl)
226: (*tp->t_mctl)(tp, TM_RTS, DMBIS);
227:
228: simple_unlock(&tp->t_lock);
229: splx(s);
230:
231: ior->io_error = D_SUCCESS;
232: (void) ds_open_done(ior);
233: return TRUE;
234: }
235:
236: boolean_t tty_close_open_reply(
237: io_req_t ior)
238: {
239: ior->io_error = D_DEVICE_DOWN;
240: (void) ds_open_done(ior);
241: return TRUE;
242: }
243:
244: /*
245: * Write to TTY.
246: * No locks may be held.
247: * Calls device start routine; must already be on master if
248: * device needs to run on master.
249: */
250: io_return_t char_write(
251: register struct tty * tp,
252: register io_req_t ior)
253: {
254: spl_t s;
255: register int count;
256: register char *data;
257: vm_offset_t addr;
258: io_return_t rc = D_SUCCESS;
259:
260: data = ior->io_data;
261: count = ior->io_count;
262: if (count == 0)
263: return rc;
264:
265: if (!(ior->io_op & IO_INBAND)) {
266: /*
267: * Copy out-of-line data into kernel address space.
268: * Since data is copied as page list, it will be
269: * accessible.
270: */
271: vm_map_copy_t copy = (vm_map_copy_t) data;
272: kern_return_t kr;
273:
274: kr = vm_map_copyout(device_io_map, &addr, copy);
275: if (kr != KERN_SUCCESS)
276: return kr;
277: data = (char *) addr;
278: }
279:
280: /*
281: * Check for tty operating.
282: */
283: s = spltty();
284: simple_lock(&tp->t_lock);
285:
286: if ((tp->t_state & TS_CARR_ON) == 0) {
287:
288: if ((tp->t_state & TS_ONDELAY) == 0) {
289: /*
290: * No delayed writes - tell caller that device is down
291: */
292: rc = D_IO_ERROR;
293: goto out;
294: }
295:
296: if (ior->io_mode & D_NOWAIT) {
297: rc = D_WOULD_BLOCK;
298: goto out;
299: }
300: }
301:
302: /*
303: * Copy data into the output buffer.
304: * Report the amount not copied.
305: */
306:
307: ior->io_residual = b_to_q(data, count, &tp->t_outq);
308:
309: /*
310: * Start hardware output.
311: */
312:
313: tp->t_state &= ~TS_TTSTOP;
314: tty_output(tp);
315:
316: if (tp->t_outq.c_cc > TTHIWAT(tp) ||
317: (tp->t_state & TS_CARR_ON) == 0) {
318:
319: /*
320: * Do not send reply until some characters have been sent.
321: */
322: ior->io_dev_ptr = (char *)tp;
323: queue_delayed_reply(&tp->t_delayed_write, ior, char_write_done);
324:
325: rc = D_IO_QUEUED;
326: }
327: out:
328: simple_unlock(&tp->t_lock);
329: splx(s);
330:
331: if (!(ior->io_op & IO_INBAND))
332: (void) vm_deallocate(device_io_map, addr, ior->io_count);
333: return rc;
334: }
335:
336: /*
337: * Retry wait for output queue emptied, for write.
338: * No locks may be held.
339: * May run on any CPU.
340: */
341: boolean_t char_write_done(
342: register io_req_t ior)
343: {
344: register struct tty *tp = (struct tty *)ior->io_dev_ptr;
345: register spl_t s = spltty();
346:
347: simple_lock(&tp->t_lock);
348: if (tp->t_outq.c_cc > TTHIWAT(tp) ||
349: (tp->t_state & TS_CARR_ON) == 0) {
350:
351: queue_delayed_reply(&tp->t_delayed_write, ior, char_write_done);
352: simple_unlock(&tp->t_lock);
353: splx(s);
354: return FALSE;
355: }
356: simple_unlock(&tp->t_lock);
357: splx(s);
358:
359: if (IP_VALID(ior->io_reply_port)) {
360: (void) (*((ior->io_op & IO_INBAND) ?
361: ds_device_write_reply_inband :
362: ds_device_write_reply))(ior->io_reply_port,
363: ior->io_reply_port_type,
364: ior->io_error,
365: (int) (ior->io_total -
366: ior->io_residual));
367: }
368: mach_device_deallocate(ior->io_device);
369: return TRUE;
370: }
371:
372: boolean_t tty_close_write_reply(
373: register io_req_t ior)
374: {
375: ior->io_residual = ior->io_count;
376: ior->io_error = D_DEVICE_DOWN;
377: (void) ds_write_done(ior);
378: return TRUE;
379: }
380:
381: /*
382: * Read from TTY.
383: * No locks may be held.
384: * May run on any CPU - does not talk to device driver.
385: */
386: io_return_t char_read(
387: register struct tty *tp,
388: register io_req_t ior)
389: {
390: spl_t s;
391: kern_return_t rc;
392:
393: /*
394: * Allocate memory for read buffer.
395: */
396: rc = device_read_alloc(ior, (vm_size_t)ior->io_count);
397: if (rc != KERN_SUCCESS)
398: return rc;
399:
400: s = spltty();
401: simple_lock(&tp->t_lock);
402: if ((tp->t_state & TS_CARR_ON) == 0) {
403:
404: if ((tp->t_state & TS_ONDELAY) == 0) {
405: /*
406: * No delayed writes - tell caller that device is down
407: */
408: rc = D_IO_ERROR;
409: goto out;
410: }
411:
412: if (ior->io_mode & D_NOWAIT) {
413: rc = D_WOULD_BLOCK;
414: goto out;
415: }
416:
417: }
418:
419: if (tp->t_inq.c_cc <= 0 ||
420: (tp->t_state & TS_CARR_ON) == 0) {
421:
422: ior->io_dev_ptr = (char *)tp;
423: queue_delayed_reply(&tp->t_delayed_read, ior, char_read_done);
424: rc = D_IO_QUEUED;
425: goto out;
426: }
427:
428: ior->io_residual = ior->io_count - q_to_b(&tp->t_inq,
429: ior->io_data,
430: (int)ior->io_count);
431: if (tp->t_state & TS_RTS_DOWN) {
432: (*tp->t_mctl)(tp, TM_RTS, DMBIS);
433: tp->t_state &= ~TS_RTS_DOWN;
434: }
435:
436: out:
437: simple_unlock(&tp->t_lock);
438: splx(s);
439: return rc;
440: }
441:
442: /*
443: * Retry wait for characters, for read.
444: * No locks may be held.
445: * May run on any CPU - does not talk to device driver.
446: */
447: boolean_t char_read_done(
448: register io_req_t ior)
449: {
450: register struct tty *tp = (struct tty *)ior->io_dev_ptr;
451: register spl_t s = spltty();
452:
453: simple_lock(&tp->t_lock);
454:
455: if (tp->t_inq.c_cc <= 0 ||
456: (tp->t_state & TS_CARR_ON) == 0) {
457:
458: queue_delayed_reply(&tp->t_delayed_read, ior, char_read_done);
459: simple_unlock(&tp->t_lock);
460: splx(s);
461: return FALSE;
462: }
463:
464: ior->io_residual = ior->io_count - q_to_b(&tp->t_inq,
465: ior->io_data,
466: (int)ior->io_count);
467: if (tp->t_state & TS_RTS_DOWN) {
468: (*tp->t_mctl)(tp, TM_RTS, DMBIS);
469: tp->t_state &= ~TS_RTS_DOWN;
470: }
471:
472: simple_unlock(&tp->t_lock);
473: splx(s);
474:
475: (void) ds_read_done(ior);
476: return TRUE;
477: }
478:
479: boolean_t tty_close_read_reply(
480: register io_req_t ior)
481: {
482: ior->io_residual = ior->io_count;
483: ior->io_error = D_DEVICE_DOWN;
484: (void) ds_read_done(ior);
485: return TRUE;
486: }
487:
488: /*
489: * Close the tty.
490: * Tty must be locked (at spltty).
491: * Iff modem control should run on master.
492: */
493: void ttyclose(
494: register struct tty *tp)
495: {
496: register io_req_t ior;
497:
498: /*
499: * Flush the read and write queues. Signal
500: * the open queue so that those waiting for open
501: * to complete will see that the tty is closed.
502: */
503: while ((ior = (io_req_t)dequeue_head(&tp->t_delayed_read)) != 0) {
504: ior->io_done = tty_close_read_reply;
505: iodone(ior);
506: }
507: while ((ior = (io_req_t)dequeue_head(&tp->t_delayed_write)) != 0) {
508: ior->io_done = tty_close_write_reply;
509: iodone(ior);
510: }
511: while ((ior = (io_req_t)dequeue_head(&tp->t_delayed_open)) != 0) {
512: ior->io_done = tty_close_open_reply;
513: iodone(ior);
514: }
515:
516: /* Close down modem */
517: if (tp->t_mctl) {
518: (*tp->t_mctl)(tp, TM_BRK|TM_RTS, DMBIC);
519: if ((tp->t_state&(TS_HUPCLS|TS_WOPEN)) || (tp->t_state&TS_ISOPEN)==0)
520: (*tp->t_mctl)(tp, TM_HUP, DMSET);
521: }
522:
523: /* only save buffering bit, and carrier */
524: tp->t_state = tp->t_state & (TS_MIN|TS_CARR_ON);
525: }
526:
527: /*
528: * Port-death routine to clean up reply messages.
529: */
530: boolean_t
531: tty_queue_clean(
532: queue_t q,
533: ipc_port_t port,
534: boolean_t (*routine)(io_req_t) )
535: {
536: register io_req_t ior;
537:
538: ior = (io_req_t)queue_first(q);
539: while (!queue_end(q, (queue_entry_t)ior)) {
540: if (ior->io_reply_port == port) {
541: remqueue(q, (queue_entry_t)ior);
542: ior->io_done = routine;
543: iodone(ior);
544: return TRUE;
545: }
546: ior = ior->io_next;
547: }
548: return FALSE;
549: }
550:
551: /*
552: * Handle port-death (dead reply port) for tty.
553: * No locks may be held.
554: * May run on any CPU.
555: */
556: boolean_t
557: tty_portdeath(
558: struct tty * tp,
559: ipc_port_t port)
560: {
561: register spl_t spl = spltty();
562: register boolean_t result;
563:
564: simple_lock(&tp->t_lock);
565:
566: /*
567: * The queues may never have been initialized
568: */
569: if (tp->t_delayed_read.next == 0) {
570: result = FALSE;
571: }
572: else {
573: result =
574: tty_queue_clean(&tp->t_delayed_read, port,
575: tty_close_read_reply)
576: || tty_queue_clean(&tp->t_delayed_write, port,
577: tty_close_write_reply)
578: || tty_queue_clean(&tp->t_delayed_open, port,
579: tty_close_open_reply);
580: }
581: simple_unlock(&tp->t_lock);
582: splx(spl);
583:
584: return result;
585: }
586:
587: /*
588: * Get TTY status.
589: * No locks may be held.
590: * May run on any CPU.
591: */
592: io_return_t tty_get_status(
593: register struct tty *tp,
594: dev_flavor_t flavor,
595: int * data, /* pointer to OUT array */
596: natural_t *count) /* out */
597: {
598: spl_t s;
599:
600: switch (flavor) {
601: case TTY_STATUS:
602: {
603: register struct tty_status *tsp =
604: (struct tty_status *) data;
605:
606: if (*count < TTY_STATUS_COUNT)
607: return (D_INVALID_OPERATION);
608:
609: s = spltty();
610: simple_lock(&tp->t_lock);
611:
612: tsp->tt_ispeed = tp->t_ispeed;
613: tsp->tt_ospeed = tp->t_ospeed;
614: tsp->tt_breakc = tp->t_breakc;
615: tsp->tt_flags = tp->t_flags;
616: if (tp->t_state & TS_HUPCLS)
617: tsp->tt_flags |= TF_HUPCLS;
618:
619: simple_unlock(&tp->t_lock);
620: splx(s);
621:
622: *count = TTY_STATUS_COUNT;
623: break;
624:
625: }
626: default:
627: return D_INVALID_OPERATION;
628: }
629: return D_SUCCESS;
630: }
631:
632: /*
633: * Set TTY status.
634: * No locks may be held.
635: * Calls device start or stop routines; must already be on master if
636: * device needs to run on master.
637: */
638: io_return_t tty_set_status(
639: register struct tty *tp,
640: dev_flavor_t flavor,
641: int * data,
642: natural_t count)
643: {
644: int s;
645:
646: switch (flavor) {
647: case TTY_FLUSH:
648: {
649: register int flags;
650: if (count < TTY_FLUSH_COUNT)
651: return D_INVALID_OPERATION;
652:
653: flags = *data;
654: if (flags == 0)
655: flags = D_READ | D_WRITE;
656:
657: s = spltty();
658: simple_lock(&tp->t_lock);
659: tty_flush(tp, flags);
660: simple_unlock(&tp->t_lock);
661: splx(s);
662:
663: break;
664: }
665: case TTY_STOP:
666: /* stop output */
667: s = spltty();
668: simple_lock(&tp->t_lock);
669: if ((tp->t_state & TS_TTSTOP) == 0) {
670: tp->t_state |= TS_TTSTOP;
671: (*tp->t_stop)(tp, 0);
672: }
673: simple_unlock(&tp->t_lock);
674: splx(s);
675: break;
676:
677: case TTY_START:
678: /* start output */
679: s = spltty();
680: simple_lock(&tp->t_lock);
681: if (tp->t_state & TS_TTSTOP) {
682: tp->t_state &= ~TS_TTSTOP;
683: tty_output(tp);
684: }
685: simple_unlock(&tp->t_lock);
686: splx(s);
687: break;
688:
689: case TTY_STATUS:
690: /* set special characters and speed */
691: {
692: register struct tty_status *tsp;
693:
694: if (count < TTY_STATUS_COUNT)
695: return D_INVALID_OPERATION;
696:
697: tsp = (struct tty_status *)data;
698:
699: if (tsp->tt_ispeed < 0 ||
700: tsp->tt_ispeed >= NSPEEDS ||
701: tsp->tt_ospeed < 0 ||
702: tsp->tt_ospeed >= NSPEEDS)
703: {
704: return D_INVALID_OPERATION;
705: }
706:
707: s = spltty();
708: simple_lock(&tp->t_lock);
709:
710: tp->t_ispeed = tsp->tt_ispeed;
711: tp->t_ospeed = tsp->tt_ospeed;
712: tp->t_breakc = tsp->tt_breakc;
713: tp->t_flags = tsp->tt_flags & ~TF_HUPCLS;
714: if (tsp->tt_flags & TF_HUPCLS)
715: tp->t_state |= TS_HUPCLS;
716:
717: simple_unlock(&tp->t_lock);
718: splx(s);
719: break;
720: }
721: default:
722: return D_INVALID_OPERATION;
723: }
724: return D_SUCCESS;
725: }
726:
727:
728: /*
729: * [internal]
730: * Queue IOR on reply queue, to wait for TTY operation.
731: * TTY must be locked (at spltty).
732: */
733: void queue_delayed_reply(
734: queue_t qh,
735: io_req_t ior,
736: boolean_t (*io_done)(io_req_t) )
737: {
738: ior->io_done = io_done;
739: enqueue_tail(qh, (queue_entry_t)ior);
740: }
741:
742: /*
743: * Retry delayed IO operations for TTY.
744: * TTY containing queue must be locked (at spltty).
745: */
746: void tty_queue_completion(
747: register queue_t qh)
748: {
749: register io_req_t ior;
750:
751: while ((ior = (io_req_t)dequeue_head(qh)) != 0) {
752: iodone(ior);
753: }
754: }
755:
756: /*
757: * Set the default special characters.
758: * Since this routine is called whenever a tty has never been opened,
759: * we can initialize the queues here.
760: */
761: void ttychars(
762: register struct tty *tp)
763: {
764: if ((tp->t_flags & TS_INIT) == 0) {
765: /*
766: * Initialize queues
767: */
768: queue_init(&tp->t_delayed_open);
769: queue_init(&tp->t_delayed_read);
770: queue_init(&tp->t_delayed_write);
771:
772: /*
773: * Initialize character buffers
774: */
775: cb_alloc(&tp->t_inq, tty_inq_size);
776:
777: /* if we might do modem flow control */
778: if (tp->t_mctl && tp->t_inq.c_hog > 30)
779: tp->t_inq.c_hog -= 30;
780:
781: cb_alloc(&tp->t_outq, tty_outq_size);
782:
783: /*
784: * Mark initialized
785: */
786: tp->t_state |= TS_INIT;
787: }
788:
789: tp->t_breakc = 0;
790: }
791:
792: /*
793: * Flush all TTY queues.
794: * Called at spltty, tty already locked.
795: * Calls device STOP routine; must already be on master if
796: * device needs to run on master.
797: */
798: void tty_flush(
799: register struct tty *tp,
800: int rw)
801: {
802: if (rw & D_READ) {
803: cb_clear(&tp->t_inq);
804: tty_queue_completion(&tp->t_delayed_read);
805: }
806: if (rw & D_WRITE) {
807: tp->t_state &= ~TS_TTSTOP;
808: (*tp->t_stop)(tp, rw);
809: cb_clear(&tp->t_outq);
810: tty_queue_completion(&tp->t_delayed_write);
811: }
812: }
813:
814: /*
815: * Restart character output after a delay timeout.
816: * Calls device start routine - must be on master CPU.
817: *
818: * Timeout routines are called only on master CPU.
819: * What if device runs on a different CPU?
820: */
821: void ttrstrt(
822: register struct tty *tp)
823: {
824: register spl_t s;
825:
826: s = spltty();
827: simple_lock(&tp->t_lock);
828:
829: tp->t_state &= ~TS_TIMEOUT;
830: ttstart (tp);
831:
832: simple_unlock(&tp->t_lock);
833: splx(s);
834: }
835:
836: /*
837: * Start output on the typewriter. It is used from the top half
838: * after some characters have been put on the output queue,
839: * from the interrupt routine to transmit the next
840: * character, and after a timeout has finished.
841: *
842: * Called at spltty, tty already locked.
843: * Must be on master CPU if device runs on master.
844: */
845: void ttstart(tp)
846: register struct tty *tp;
847: {
848: if ((tp->t_state & (TS_TIMEOUT|TS_TTSTOP|TS_BUSY)) == 0) {
849: /*
850: * Start up the hardware again
851: */
852: (*tp->t_start)(tp);
853:
854: /*
855: * Wake up those waiting for write completion.
856: */
857: if (tp->t_outq.c_cc <= TTLOWAT(tp))
858: tty_queue_completion(&tp->t_delayed_write);
859: }
860: }
861:
862: /*
863: * Start character output, if the device is not busy or
864: * stopped or waiting for a timeout.
865: *
866: * Called at spltty, tty already locked.
867: * Must be on master CPU if device runs on master.
868: */
869: void tty_output(
870: register struct tty *tp)
871: {
872: if ((tp->t_state & (TS_TIMEOUT|TS_TTSTOP|TS_BUSY)) == 0) {
873: /*
874: * Not busy. Start output.
875: */
876: (*tp->t_start)(tp);
877:
878: /*
879: * Wake up those waiting for write completion.
880: */
881: if (tp->t_outq.c_cc <= TTLOWAT(tp))
882: tty_queue_completion(&tp->t_delayed_write);
883: }
884: }
885:
886: /*
887: * Send any buffered recvd chars up to user
888: */
889: void ttypush(
890: register struct tty *tp)
891: {
892: spl_t s = spltty();
893: register int state;
894:
895: simple_lock(&tp->t_lock);
896:
897: /*
898: The pdma timeout has gone off.
899: If no character has been received since the timeout
900: was set, push any pending characters up.
901: If any characters were received in the last interval
902: then just reset the timeout and the character received bit.
903: */
904:
905: state = tp->t_state;
906:
907: if (state & TS_MIN_TO)
908: {
909: if (state & TS_MIN_TO_RCV)
910: { /* a character was received */
911: tp->t_state = state & ~TS_MIN_TO_RCV;
912: timeout(ttypush,tp,pdma_timeouts[tp->t_ispeed]);
913: }
914: else
915: {
916: tp->t_state = state & ~TS_MIN_TO;
917: if (tp->t_inq.c_cc) /* pending characters */
918: tty_queue_completion(&tp->t_delayed_read);
919: }
920: }
921: else
922: {
923: tp->t_state = state & ~TS_MIN_TO_RCV;/* sanity */
924: }
925:
926: simple_unlock(&tp->t_lock);
927: splx(s);
928: }
929:
930: /*
931: * Put input character on input queue.
932: *
933: * Called at spltty, tty already locked.
934: */
935: void ttyinput(
936: unsigned int c,
937: struct tty *tp)
938: {
939: if (tp->t_inq.c_cc >= tp->t_inq.c_hog) {
940: /*
941: * Do not want to overflow input queue
942: */
943: if (tp->t_mctl) {
944: (*tp->t_mctl)(tp, TM_RTS, DMBIC);
945: tp->t_state |= TS_RTS_DOWN;
946: }
947: tty_queue_completion(&tp->t_delayed_read);
948: return;
949:
950: }
951:
952: c &= 0xff;
953:
954: (void) putc(c, &tp->t_inq);
955: if ((tp->t_state & TS_MIN) == 0 ||
956: tp->t_inq.c_cc > pdma_water_mark[tp->t_ispeed])
957: {
958: /*
959: * No input buffering, or input minimum exceeded.
960: * Grab a request from input queue and queue it
961: * to io_done thread.
962: */
963: if (tp->t_state & TS_MIN_TO) {
964: tp->t_state &= ~(TS_MIN_TO|TS_MIN_TO_RCV);
965: untimeout(ttypush, tp);
966: }
967: tty_queue_completion(&tp->t_delayed_read);
968: }
969: else {
970: /*
971: * Not enough characters.
972: * If no timeout is set, initiate the timeout
973: * Otherwise set the character received during timeout interval
974: * flag.
975: * One alternative approach would be just to reset the timeout
976: * into the future, but this involves making a timeout/untimeout
977: * call on every character.
978: */
979: register int ptime = pdma_timeouts[tp->t_ispeed];
980: if (ptime > 0)
981: {
982: if ((tp->t_state & TS_MIN_TO) == 0)
983: {
984: tp->t_state |= TS_MIN_TO;
985: timeout(ttypush, tp, ptime);
986: }
987: else
988: {
989: tp->t_state |= TS_MIN_TO_RCV;
990: }
991: }
992: }
993: }
994:
995: /*
996: * Put many characters on input queue.
997: *
998: * Called at spltty, tty already locked.
999: */
1000: void ttyinput_many(
1001: struct tty *tp,
1002: unsigned char *chars,
1003: int count)
1004: {
1005: /*
1006: * Do not want to overflow input queue
1007: */
1008: if (tp->t_inq.c_cc < tp->t_inq.c_hog)
1009: count -= b_to_q( chars, count, &tp->t_inq);
1010:
1011: tty_queue_completion(&tp->t_delayed_read);
1012: }
1013:
1014:
1015: /*
1016: * Handle modem control transition on a tty.
1017: * Flag indicates new state of carrier.
1018: * Returns FALSE if the line should be turned off.
1019: *
1020: * Called at spltty, tty already locked.
1021: */
1022: boolean_t ttymodem(
1023: struct tty * tp,
1024: boolean_t carrier_up)
1025: {
1026: if ((tp->t_state&TS_WOPEN) == 0 && (tp->t_flags & MDMBUF)) {
1027: /*
1028: * Flow control by carrier. Carrier down stops
1029: * output; carrier up restarts output.
1030: */
1031: if (carrier_up) {
1032: tp->t_state &= ~TS_TTSTOP;
1033: tty_output(tp);
1034: }
1035: else if ((tp->t_state&TS_TTSTOP) == 0) {
1036: tp->t_state |= TS_TTSTOP;
1037: (*tp->t_stop)(tp, 0);
1038: }
1039: }
1040: else if (carrier_up) {
1041: /*
1042: * Carrier now on.
1043: */
1044: tp->t_state |= TS_CARR_ON;
1045: tt_open_wakeup(tp);
1046: }
1047: else {
1048: /*
1049: * Lost carrier.
1050: */
1051: tp->t_state &= ~TS_CARR_ON;
1052: if (tp->t_state & TS_ISOPEN &&
1053: (tp->t_flags & NOHANG) == 0)
1054: {
1055: /*
1056: * Hang up TTY if carrier drops.
1057: * Need to alert users, somehow...
1058: */
1059: tty_flush(tp, D_READ|D_WRITE);
1060: return FALSE;
1061: }
1062: }
1063: return TRUE;
1064: }
1065:
1066: /*
1067: * Similarly, handle transitions on the ClearToSend
1068: * signal. Nowadays, it is used by many modems as
1069: * a flow-control device: they turn it down to stop
1070: * us from sending more chars. We do the same with
1071: * the RequestToSend signal. [Yes, that is exactly
1072: * why those signals are defined in the standard.]
1073: *
1074: * Tty must be locked and on master.
1075: */
1076: tty_cts(
1077: struct tty * tp,
1078: boolean_t cts_up)
1079: {
1080: if (tp->t_state & TS_ISOPEN){
1081: if (cts_up) {
1082: tp->t_state &= ~(TS_TTSTOP|TS_BUSY);
1083: tty_output(tp);
1084: } else {
1085: tp->t_state |= (TS_TTSTOP|TS_BUSY);
1086: (*tp->t_stop)(tp, D_WRITE);
1087: }
1088: }
1089: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.