![[BACK]](/icons/back.gif){kind=icon}
Return to tty.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / prex / dev / gen|
Return to tty.c CVS log | Up to [local] / prex / dev / gen |
1.1 nbrk 1: /*-
2: * Copyright (c) 1982, 1986, 1990, 1991, 1993
3: * The Regents of the University of California. All rights reserved.
4: * (c) UNIX System Laboratories, Inc.
5: * All or some portions of this file are derived from material licensed
6: * to the University of California by American Telephone and Telegraph
7: * Co. or Unix System Laboratories, Inc. and are reproduced herein with
8: * the permission of UNIX System Laboratories, Inc.
9: *
10: * Redistribution and use in source and binary forms, with or without
11: * modification, are permitted provided that the following conditions
12: * are met:
13: * 1. Redistributions of source code must retain the above copyright
14: * notice, this list of conditions and the following disclaimer.
15: * 2. Redistributions in binary form must reproduce the above copyright
16: * notice, this list of conditions and the following disclaimer in the
17: * documentation and/or other materials provided with the distribution.
18: * 3. Neither the name of the University nor the names of its contributors
19: * may be used to endorse or promote products derived from this software
20: * without specific prior written permission.
21: *
22: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
23: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
26: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
27: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
28: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
29: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
31: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32: * SUCH DAMAGE.
33: *
34: * @(#)tty.c 8.13 (Berkeley) 1/9/95
35: */
36:
37: /*
38: * tty.c - TTY device
39: */
40:
41: #include <driver.h>
42: #include <sys/signal.h>
43: #include <sys/tty.h>
44: #include <sys/termios.h>
45:
46: #define FREAD 0x0001
47: #define FWRITE 0x0002
48:
49: void tty_output(int c, struct tty *tp);
50: static int tty_init(void);
51:
52: /*
53: * Driver structure
54: */
55: struct driver tty_drv = {
56: /* name */ "TTY device",
57: /* order */ 10, /* must be larger than console */
58: /* init */ tty_init,
59: };
60:
61: static device_t tty_dev;
62:
63: /* task to dispatch the tty signal */
64: static task_t sig_task;
65:
66: /* default control characters */
67: static cc_t ttydefchars[NCCS] = TTYDEFCHARS;
68:
69: #define is_ctrl(c) ((c) < 32 || (c) == 0x7f)
70:
71: /*
72: * TTY queue operations
73: */
74: #define ttyq_next(i) (((i) + 1) & (TTYQ_SIZE - 1))
75: #define ttyq_prev(i) (((i) - 1) & (TTYQ_SIZE - 1))
76: #define ttyq_full(q) ((q)->tq_count >= TTYQ_SIZE)
77: #define ttyq_empty(q) ((q)->tq_count == 0)
78:
79: /*
80: * Get a character from a queue.
81: */
82: int
83: ttyq_getc(struct tty_queue *tq)
84: {
85: int c;
86:
87: if (ttyq_empty(tq))
88: return -1;
89: irq_lock();
90: c = tq->tq_buf[tq->tq_head];
91: tq->tq_head = ttyq_next(tq->tq_head);
92: tq->tq_count--;
93: irq_unlock();
94: return c;
95: }
96:
97: /*
98: * Put a character into a queue.
99: */
100: void
101: ttyq_putc(int c, struct tty_queue *tq)
102: {
103:
104: if (ttyq_full(tq))
105: return;
106: irq_lock();
107: tq->tq_buf[tq->tq_tail] = c;
108: tq->tq_tail = ttyq_next(tq->tq_tail);
109: tq->tq_count++;
110: irq_unlock();
111: }
112:
113: /*
114: * Remove the last character in a queue and return it.
115: */
116: int
117: ttyq_unputc(struct tty_queue *tq)
118: {
119: int c;
120:
121: if (ttyq_empty(tq))
122: return -1;
123: irq_lock();
124: tq->tq_tail = ttyq_prev(tq->tq_tail);
125: c = tq->tq_buf[tq->tq_tail];
126: tq->tq_count--;
127: irq_unlock();
128: return c;
129: }
130:
131: /*
132: * Put the chars in the from queue on the end of the to queue.
133: */
134: static void
135: tty_catq(struct tty_queue *from, struct tty_queue *to)
136: {
137: int c;
138:
139: while ((c = ttyq_getc(from)) != -1)
140: ttyq_putc(c, to);
141: }
142:
143: /*
144: * Rubout one character from the rawq of tp
145: */
146: static void
147: tty_rubout(struct tty *tp)
148: {
149:
150: if (!(tp->t_lflag & ECHO))
151: return;
152: if (tp->t_lflag & ECHOE) {
153: tty_output('\b', tp);
154: tty_output(' ', tp);
155: tty_output('\b', tp);
156: } else
157: tty_output(tp->t_cc[VERASE], tp);
158: }
159:
160: /*
161: * Echo char
162: */
163: static void
164: tty_echo(int c, struct tty *tp)
165: {
166:
167: if (!(tp->t_lflag & ECHO)) {
168: if (c == '\n' && (tp->t_lflag & ECHONL))
169: tty_output('\n', tp);
170: return;
171: }
172: if (is_ctrl(c) && c != '\n' && c != '\t' && c != '\b') {
173: tty_output('^', tp);
174: tty_output(c + 'A' - 1, tp);
175: } else
176: tty_output(c, tp);
177: }
178:
179: /*
180: * Start output.
181: */
182: static void
183: tty_start(struct tty *tp)
184: {
185:
186: if (tp->t_state & TS_TTSTOP)
187: return;
188: if (tp->t_output != NULL)
189: (*tp->t_output)(tp);
190: }
191:
192: /*
193: * Flush tty read and/or write queues, notifying anyone waiting.
194: */
195: static void
196: tty_flush(struct tty *tp, int rw)
197: {
198:
199: if (rw & FREAD)
200: sched_wakeup(&tp->t_input_event);
201: if (rw & FWRITE) {
202: tp->t_state &= ~TS_TTSTOP;
203: tty_start(tp);
204: }
205: }
206:
207: /*
208: * Process input of a single character received on a tty.
209: * echo if required.
210: * This will be called with interrupt level.
211: */
212: void
213: tty_input(int c, struct tty *tp)
214: {
215: unsigned char *cc;
216: tcflag_t iflag, lflag;
217: int sig = -1;
218:
219: lflag = tp->t_lflag;
220: iflag = tp->t_iflag;
221: cc = tp->t_cc;
222:
223: /* IGNCR, ICRNL, INLCR */
224: if (c == '\r') {
225: if (iflag & IGNCR)
226: goto endcase;
227: else if (iflag & ICRNL)
228: c = '\n';
229: } else if (c == '\n' && (iflag & INLCR))
230: c = '\r';
231:
232: if (iflag & IXON) {
233: /* stop (^S) */
234: if (c == cc[VSTOP]) {
235: if (!(tp->t_state & TS_TTSTOP)) {
236: tp->t_state |= TS_TTSTOP;
237: return;
238: }
239: if (c != cc[VSTART])
240: return;
241: /* if VSTART == VSTOP then toggle */
242: goto endcase;
243: }
244: /* start (^Q) */
245: if (c == cc[VSTART])
246: goto restartoutput;
247: }
248: if (lflag & ICANON) {
249: /* erase (^H / ^?) or backspace */
250: if (c == cc[VERASE] || c == '\b') {
251: if (!ttyq_empty(&tp->t_rawq)) {
252: ttyq_unputc(&tp->t_rawq);
253: tty_rubout(tp);
254: }
255: goto endcase;
256: }
257: /* kill (^U) */
258: if (c == cc[VKILL]) {
259: while (!ttyq_empty(&tp->t_rawq)) {
260: ttyq_unputc(&tp->t_rawq);
261: tty_rubout(tp);
262: }
263: goto endcase;
264: }
265: }
266: if (lflag & ISIG) {
267: /* quit (^C) */
268: if (c == cc[VINTR] || c == cc[VQUIT]) {
269: if (!(lflag & NOFLSH))
270: tty_flush(tp, FREAD | FWRITE);
271: tty_echo(c, tp);
272: sig = (c == cc[VINTR]) ? SIGINT : SIGQUIT;
273: goto endcase;
274: }
275: /* suspend (^Z) */
276: if (c == cc[VSUSP]) {
277: if (!(lflag & NOFLSH))
278: tty_flush(tp, FREAD | FWRITE);
279: tty_echo(c, tp);
280: sig = SIGTSTP;
281: goto endcase;
282: }
283: }
284:
285: /*
286: * Check for input buffer overflow
287: */
288: if (ttyq_full(&tp->t_rawq)) {
289: tty_flush(tp, FREAD | FWRITE);
290: goto endcase;
291: }
292: ttyq_putc(c, &tp->t_rawq);
293:
294: if (lflag & ICANON) {
295: if (c == '\n' || c == cc[VEOF] || c == cc[VEOL]) {
296: tty_catq(&tp->t_rawq, &tp->t_canq);
297: sched_wakeup(&tp->t_input_event);
298: }
299: } else
300: sched_wakeup(&tp->t_input_event);
301:
302: if (lflag & ECHO)
303: tty_echo(c, tp);
304: endcase:
305: /*
306: * IXANY means allow any character to restart output.
307: */
308: if ((tp->t_state & TS_TTSTOP) && (iflag & IXANY) == 0 &&
309: cc[VSTART] != cc[VSTOP])
310: return;
311: restartoutput:
312: tp->t_state &= ~TS_TTSTOP;
313:
314: if (sig != -1) {
315: if (sig_task)
316: exception_post(sig_task, sig);
317: }
318: tty_start(tp);
319: }
320:
321: /*
322: * Output a single character on a tty, doing output processing
323: * as needed (expanding tabs, newline processing, etc.).
324: */
325: void
326: tty_output(int c, struct tty *tp)
327: {
328: int i, col;
329:
330: if ((tp->t_lflag & ICANON) == 0) {
331: ttyq_putc(c, &tp->t_outq);
332: return;
333: }
334: /* Expand tab */
335: if (c == '\t' && (tp->t_oflag & OXTABS)) {
336: i = 8 - (tp->t_column & 7);
337: tp->t_column += i;
338: do
339: ttyq_putc(' ', &tp->t_outq);
340: while (--i > 0);
341: return;
342: }
343: /* Translate newline into "\r\n" */
344: if (c == '\n' && (tp->t_oflag & ONLCR))
345: ttyq_putc('\r', &tp->t_outq);
346:
347: ttyq_putc(c, &tp->t_outq);
348:
349: col = tp->t_column;
350: switch (c) {
351: case '\b': /* back space */
352: if (col > 0)
353: --col;
354: break;
355: case '\t': /* tab */
356: col = (col + 8) & ~7;
357: break;
358: case '\n': /* newline */
359: col = 0;
360: break;
361: case '\r': /* return */
362: col = 0;
363: break;
364: default:
365: if (!is_ctrl(c))
366: ++col;
367: break;
368: }
369: tp->t_column = col;
370: return;
371: }
372:
373: /*
374: * Process a read call on a tty device.
375: */
376: int
377: tty_read(struct tty *tp, char *buf, size_t *nbyte)
378: {
379: unsigned char *cc;
380: struct tty_queue *qp;
381: int rc, c;
382: size_t count = 0;
383: tcflag_t lflag;
384:
385: lflag = tp->t_lflag;
386: cc = tp->t_cc;
387: qp = (lflag & ICANON) ? &tp->t_canq : &tp->t_rawq;
388:
389: /* If there is no input, wait it */
390: while (ttyq_empty(qp)) {
391: rc = sched_sleep(&tp->t_input_event);
392: if (rc == SLP_INTR)
393: return EINTR;
394: }
395: while (count < *nbyte) {
396: if ((c = ttyq_getc(qp)) == -1)
397: break;
398: if (c == cc[VEOF] && (lflag & ICANON))
399: break;
400: count++;
401: if (umem_copyout(&c, buf, 1))
402: return EFAULT;
403: if ((lflag & ICANON) && (c == '\n' || c == cc[VEOL]))
404: break;
405: buf++;
406: }
407: *nbyte = count;
408: return 0;
409: }
410:
411: /*
412: * Process a write call on a tty device.
413: */
414: int
415: tty_write(struct tty *tp, char *buf, size_t *nbyte)
416: {
417: size_t remain, count = 0;
418: int c;
419:
420: remain = *nbyte;
421: while (remain > 0) {
422: if (tp->t_outq.tq_count >= TTYQ_HIWAT) {
423: tty_start(tp);
424: continue;
425: }
426: if (umem_copyin(buf, &c, 1))
427: return EFAULT;
428: tty_output(c, tp);
429: buf++;
430: remain--;
431: count++;
432: }
433: tty_start(tp);
434: *nbyte = count;
435: return 0;
436: }
437:
438: /*
439: * Ioctls for all tty devices.
440: */
441: int
442: tty_ioctl(struct tty *tp, u_long cmd, void *data)
443: {
444: int flags;
445:
446: switch (cmd) {
447: case TIOCGETA:
448: if (umem_copyout(&tp->t_termios, data,
449: sizeof(struct termios)))
450: return EFAULT;
451: break;
452: case TIOCSETAW:
453: case TIOCSETAF:
454: tty_flush(tp, flags);
455: /* FALLTHROUGH */
456: case TIOCSETA:
457: if (umem_copyin(data, &tp->t_termios,
458: sizeof(struct termios)))
459: return EFAULT;
460: break;
461: case TIOCSPGRP: /* set pgrp of tty */
462: if (umem_copyin(data, &tp->t_pgid, sizeof(pid_t)))
463: return EFAULT;
464: break;
465: case TIOCGPGRP:
466: if (umem_copyout(&tp->t_pgid, data, sizeof(pid_t)))
467: return EFAULT;
468: break;
469: case TIOCFLUSH:
470: if (umem_copyin(data, &flags, sizeof(flags)))
471: return EFAULT;
472: break;
473: if (flags == 0)
474: flags = FREAD | FWRITE;
475: else
476: flags &= FREAD | FWRITE;
477: tty_flush(tp, flags);
478: break;
479: case TIOCSTART:
480: if (tp->t_state & TS_TTSTOP) {
481: tp->t_state &= ~TS_TTSTOP;
482: tty_start(tp);
483: }
484: break;
485: case TIOCSTOP:
486: if (!(tp->t_state & TS_TTSTOP)) {
487: tp->t_state |= TS_TTSTOP;
488: }
489: break;
490: case TIOCGWINSZ:
491: if (umem_copyout(&tp->t_winsize, data,
492: sizeof(struct winsize)))
493: return EFAULT;
494: break;
495: case TIOCSWINSZ:
496: if (umem_copyin(&tp->t_winsize, data,
497: sizeof(struct winsize)))
498: return EFAULT;
499: break;
500: case TIOCSETSIGT:
501: if (umem_copyin(data, &sig_task, sizeof(task_t)))
502: return EFAULT;
503: break;
504: }
505: return 0;
506: }
507:
508: /*
509: * Register tty device.
510: */
511: int
512: tty_register(struct devio *io, struct tty *tp, void (*output)(struct tty*))
513: {
514:
515: /* We support only one tty device */
516: if (tty_dev != DEVICE_NULL)
517: return -1;
518:
519: /* Create TTY device as an alias of the registered device. */
520: tty_dev = device_create(io, "tty", DF_CHR);
521: if (tty_dev == DEVICE_NULL)
522: return -1;
523:
524: /* Initialize tty */
525: memset(tp, 0, sizeof(struct tty));
526: memcpy(&tp->t_termios.c_cc, ttydefchars, sizeof(ttydefchars));
527: event_init(&tp->t_input_event, "TTY input");
528: tp->t_iflag = TTYDEF_IFLAG;
529: tp->t_oflag = TTYDEF_OFLAG;
530: tp->t_cflag = TTYDEF_CFLAG;
531: tp->t_lflag = TTYDEF_LFLAG;
532: tp->t_ispeed = TTYDEF_SPEED;
533: tp->t_ospeed = TTYDEF_SPEED;
534: tp->t_output = output;
535: return 0;
536: }
537:
538: /*
539: * Init
540: */
541: static int
542: tty_init(void)
543: {
544:
545: return 0;
546: }