![[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-old / dev / gen|
Return to tty.c CVS log | Up to [local] / prex-old / 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/ttycom.h>
! 45: #include <sys/termios.h>
! 46:
! 47: #define FREAD 0x0001
! 48: #define FWRITE 0x0002
! 49:
! 50: void tty_output(int c, struct tty *tp);
! 51: static int tty_init(void);
! 52:
! 53: /*
! 54: * Driver structure
! 55: */
! 56: struct driver tty_drv = {
! 57: /* name */ "TTY device",
! 58: /* order */ 10, /* must be larger than console */
! 59: /* init */ tty_init,
! 60: };
! 61:
! 62: static device_t tty_dev;
! 63:
! 64: /* task to dispatch the tty signal */
! 65: static task_t sig_task;
! 66:
! 67: /* default control characters */
! 68: static cc_t ttydefchars[NCCS] = TTYDEFCHARS;
! 69:
! 70: #define is_ctrl(c) ((c) < 32 || (c) == 0x7f)
! 71:
! 72: /*
! 73: * TTY queue operations
! 74: */
! 75: #define ttyq_next(i) (((i) + 1) & (TTYQ_SIZE - 1))
! 76: #define ttyq_prev(i) (((i) - 1) & (TTYQ_SIZE - 1))
! 77: #define ttyq_full(q) ((q)->count >= TTYQ_SIZE)
! 78: #define ttyq_empty(q) ((q)->count == 0)
! 79:
! 80: /*
! 81: * Get a character from a queue.
! 82: */
! 83: int
! 84: ttyq_getc(struct tty_queue *tq)
! 85: {
! 86: int c;
! 87:
! 88: if (ttyq_empty(tq))
! 89: return -1;
! 90: irq_lock();
! 91: c = tq->buf[tq->head];
! 92: tq->head = ttyq_next(tq->head);
! 93: tq->count--;
! 94: irq_unlock();
! 95: return c;
! 96: }
! 97:
! 98: /*
! 99: * Put a character into a queue.
! 100: */
! 101: void
! 102: ttyq_putc(int c, struct tty_queue *tq)
! 103: {
! 104:
! 105: if (ttyq_full(tq))
! 106: return;
! 107: irq_lock();
! 108: tq->buf[tq->tail] = c;
! 109: tq->tail = ttyq_next(tq->tail);
! 110: tq->count++;
! 111: irq_unlock();
! 112: }
! 113:
! 114: /*
! 115: * Remove the last character in a queue and return it.
! 116: */
! 117: int
! 118: ttyq_unputc(struct tty_queue *tq)
! 119: {
! 120: int c;
! 121:
! 122: if (ttyq_empty(tq))
! 123: return -1;
! 124: irq_lock();
! 125: tq->tail = ttyq_prev(tq->tail);
! 126: c = tq->buf[tq->tail];
! 127: tq->count--;
! 128: irq_unlock();
! 129: return c;
! 130: }
! 131:
! 132: /*
! 133: * Put the chars in the from queue on the end of the to queue.
! 134: */
! 135: static void
! 136: tty_catq(struct tty_queue *from, struct tty_queue *to)
! 137: {
! 138: int c;
! 139:
! 140: while ((c = ttyq_getc(from)) != -1)
! 141: ttyq_putc(c, to);
! 142: }
! 143:
! 144: /*
! 145: * Rubout one character from the rawq of tp
! 146: */
! 147: static void
! 148: tty_rubout(struct tty *tp)
! 149: {
! 150:
! 151: if (!(tp->t_lflag & ECHO))
! 152: return;
! 153: if (tp->t_lflag & ECHOE) {
! 154: tty_output('\b', tp);
! 155: tty_output(' ', tp);
! 156: tty_output('\b', tp);
! 157: } else
! 158: tty_output(tp->t_cc[VERASE], tp);
! 159: }
! 160:
! 161: /*
! 162: * Echo char
! 163: */
! 164: static void
! 165: tty_echo(int c, struct tty *tp)
! 166: {
! 167:
! 168: if (!(tp->t_lflag & ECHO)) {
! 169: if (c == '\n' && (tp->t_lflag & ECHONL))
! 170: tty_output('\n', tp);
! 171: return;
! 172: }
! 173: if (is_ctrl(c) && c != '\n' && c != '\t' && c != '\b') {
! 174: tty_output('^', tp);
! 175: tty_output(c + 'A' - 1, tp);
! 176: } else
! 177: tty_output(c, tp);
! 178: }
! 179:
! 180: /*
! 181: * Start output.
! 182: */
! 183: void
! 184: tty_start(struct tty *tp)
! 185: {
! 186:
! 187: if (tp->t_state & TS_TTSTOP)
! 188: return;
! 189: if (tp->t_output != NULL)
! 190: (*tp->t_output)(tp);
! 191: }
! 192:
! 193: /*
! 194: * Flush tty read and/or write queues, notifying anyone waiting.
! 195: */
! 196: void
! 197: tty_flush(struct tty *tp, int rw)
! 198: {
! 199:
! 200: if (rw & FREAD)
! 201: sched_wakeup(&tp->t_input_event);
! 202: if (rw & FWRITE) {
! 203: tp->t_state &= ~TS_TTSTOP;
! 204: tty_start(tp);
! 205: }
! 206: }
! 207:
! 208: /*
! 209: * Process input of a single character received on a tty.
! 210: * echo if required.
! 211: * This will be called with interrupt level.
! 212: */
! 213: void
! 214: tty_input(int c, struct tty *tp)
! 215: {
! 216: unsigned char *cc;
! 217: tcflag_t iflag, lflag;
! 218: int sig = -1;
! 219:
! 220: lflag = tp->t_lflag;
! 221: iflag = tp->t_iflag;
! 222: cc = tp->t_cc;
! 223:
! 224: /* IGNCR, ICRNL, INLCR */
! 225: if (c == '\r') {
! 226: if (iflag & IGNCR)
! 227: goto endcase;
! 228: else if (iflag & ICRNL)
! 229: c = '\n';
! 230: } else if (c == '\n' && (iflag & INLCR))
! 231: c = '\r';
! 232:
! 233: if (iflag & IXON) {
! 234: /* stop (^S) */
! 235: if (c == cc[VSTOP]) {
! 236: if (!(tp->t_state & TS_TTSTOP)) {
! 237: tp->t_state |= TS_TTSTOP;
! 238: return;
! 239: }
! 240: if (c != cc[VSTART])
! 241: return;
! 242: /* if VSTART == VSTOP then toggle */
! 243: goto endcase;
! 244: }
! 245: /* start (^Q) */
! 246: if (c == cc[VSTART])
! 247: goto restartoutput;
! 248: }
! 249: if (lflag & ICANON) {
! 250: /* erase (^H / ^?) or backspace */
! 251: if (c == cc[VERASE] || c == '\b') {
! 252: if (!ttyq_empty(&tp->t_rawq)) {
! 253: ttyq_unputc(&tp->t_rawq);
! 254: tty_rubout(tp);
! 255: }
! 256: goto endcase;
! 257: }
! 258: /* kill (^U) */
! 259: if (c == cc[VKILL]) {
! 260: while (!ttyq_empty(&tp->t_rawq)) {
! 261: ttyq_unputc(&tp->t_rawq);
! 262: tty_rubout(tp);
! 263: }
! 264: goto endcase;
! 265: }
! 266: }
! 267: if (lflag & ISIG) {
! 268: /* quit (^C) */
! 269: if (c == cc[VINTR] || c == cc[VQUIT]) {
! 270: if (!(lflag & NOFLSH))
! 271: tty_flush(tp, FREAD | FWRITE);
! 272: tty_echo(c, tp);
! 273: sig = (c == cc[VINTR]) ? SIGINT : SIGQUIT;
! 274: goto endcase;
! 275: }
! 276: /* suspend (^Z) */
! 277: if (c == cc[VSUSP]) {
! 278: if (!(lflag & NOFLSH))
! 279: tty_flush(tp, FREAD | FWRITE);
! 280: tty_echo(c, tp);
! 281: sig = SIGTSTP;
! 282: goto endcase;
! 283: }
! 284: }
! 285:
! 286: /*
! 287: * Check for input buffer overflow
! 288: */
! 289: if (ttyq_full(&tp->t_rawq)) {
! 290: tty_flush(tp, FREAD | FWRITE);
! 291: goto endcase;
! 292: }
! 293: ttyq_putc(c, &tp->t_rawq);
! 294:
! 295: if (lflag & ICANON) {
! 296: if (c == '\n' || c == cc[VEOF] || c == cc[VEOL]) {
! 297: tty_catq(&tp->t_rawq, &tp->t_canq);
! 298: sched_wakeup(&tp->t_input_event);
! 299: }
! 300: } else
! 301: sched_wakeup(&tp->t_input_event);
! 302:
! 303: if (lflag & ECHO)
! 304: tty_echo(c, tp);
! 305: endcase:
! 306: /*
! 307: * IXANY means allow any character to restart output.
! 308: */
! 309: if ((tp->t_state & TS_TTSTOP) && (iflag & IXANY) == 0 &&
! 310: cc[VSTART] != cc[VSTOP])
! 311: return;
! 312: restartoutput:
! 313: tp->t_state &= ~TS_TTSTOP;
! 314:
! 315: if (sig != -1) {
! 316: if (sig_task)
! 317: exception_post(sig_task, sig);
! 318: }
! 319: tty_start(tp);
! 320: }
! 321:
! 322: /*
! 323: * Output a single character on a tty, doing output processing
! 324: * as needed (expanding tabs, newline processing, etc.).
! 325: */
! 326: void
! 327: tty_output(int c, struct tty *tp)
! 328: {
! 329: int i, col;
! 330:
! 331: if ((tp->t_lflag & ICANON) == 0) {
! 332: ttyq_putc(c, &tp->t_outq);
! 333: return;
! 334: }
! 335: /* Expand tab */
! 336: if (c == '\t' && (tp->t_oflag & OXTABS)) {
! 337: i = 8 - (tp->t_column & 7);
! 338: tp->t_column += i;
! 339: do
! 340: ttyq_putc(' ', &tp->t_outq);
! 341: while (--i > 0);
! 342: return;
! 343: }
! 344: /* Translate newline into "\r\n" */
! 345: if (c == '\n' && (tp->t_oflag & ONLCR))
! 346: ttyq_putc('\r', &tp->t_outq);
! 347:
! 348: ttyq_putc(c, &tp->t_outq);
! 349:
! 350: col = tp->t_column;
! 351: switch (c) {
! 352: case '\b': /* back space */
! 353: if (col > 0)
! 354: --col;
! 355: break;
! 356: case '\t': /* tab */
! 357: col = (col + 8) & ~7;
! 358: break;
! 359: case '\n': /* newline */
! 360: col = 0;
! 361: break;
! 362: case '\r': /* return */
! 363: col = 0;
! 364: break;
! 365: default:
! 366: if (!is_ctrl(c))
! 367: ++col;
! 368: break;
! 369: }
! 370: tp->t_column = col;
! 371: return;
! 372: }
! 373:
! 374: /*
! 375: * Read
! 376: */
! 377: int
! 378: tty_read(struct tty *tp, char *buf, size_t *nbytes)
! 379: {
! 380: unsigned char *cc;
! 381: struct tty_queue *qp;
! 382: int rc, c;
! 383: size_t count = 0;
! 384: tcflag_t lflag;
! 385:
! 386: lflag = tp->t_lflag;
! 387: cc = tp->t_cc;
! 388: qp = (lflag & ICANON) ? &tp->t_canq : &tp->t_rawq;
! 389:
! 390: /* If there is no input, wait it */
! 391: while (ttyq_empty(qp)) {
! 392: rc = sched_sleep(&tp->t_input_event);
! 393: if (rc == SLP_INTR)
! 394: return EINTR;
! 395: }
! 396: while (count < *nbytes) {
! 397: if ((c = ttyq_getc(qp)) == -1)
! 398: break;
! 399: count++;
! 400: if (c == cc[VEOF] && (lflag & ICANON))
! 401: break;
! 402: *buf = c;
! 403: if ((lflag & ICANON) && (c == '\n' || c == cc[VEOL]))
! 404: break;
! 405: buf++;
! 406: }
! 407: *nbytes = count;
! 408: return 0;
! 409: }
! 410:
! 411: /*
! 412: * Write
! 413: */
! 414: int
! 415: tty_write(struct tty *tp, char *buf, size_t *nbyte)
! 416: {
! 417: size_t remain, count = 0;
! 418:
! 419: remain = *nbyte;
! 420: while (remain > 0) {
! 421: if (tp->t_outq.count >= TTYQ_HIWAT) {
! 422: tty_start(tp);
! 423: continue;
! 424: }
! 425: tty_output(*buf, tp);
! 426: buf++;
! 427: remain--;
! 428: count++;
! 429: }
! 430: tty_start(tp);
! 431: *nbyte = count;
! 432: return 0;
! 433: }
! 434:
! 435: /*
! 436: * Ioctls for all tty devices.
! 437: */
! 438: int
! 439: tty_ioctl(struct tty *tp, u_long cmd, void *data)
! 440: {
! 441: int flags;
! 442:
! 443: switch (cmd) {
! 444: case TIOCGETA:
! 445: if (umem_copyout(&tp->t_termios, data,
! 446: sizeof(struct termios)))
! 447: return EFAULT;
! 448: break;
! 449: case TIOCSETAW:
! 450: case TIOCSETAF:
! 451: tty_flush(tp, flags);
! 452: /* fallthrouth */
! 453: case TIOCSETA:
! 454: if (umem_copyin(data, &tp->t_termios,
! 455: sizeof(struct termios)))
! 456: return EFAULT;
! 457: break;
! 458: case TIOCSPGRP: /* set pgrp of tty */
! 459: if (umem_copyin(data, &tp->t_pgid, sizeof(pid_t)))
! 460: return EFAULT;
! 461: break;
! 462: case TIOCGPGRP:
! 463: if (umem_copyout(&tp->t_pgid, data, sizeof(pid_t)))
! 464: return EFAULT;
! 465: break;
! 466: case TIOCFLUSH:
! 467: if (umem_copyin(data, &flags, sizeof(flags)))
! 468: return EFAULT;
! 469: break;
! 470: if (flags == 0)
! 471: flags = FREAD | FWRITE;
! 472: else
! 473: flags &= FREAD | FWRITE;
! 474: tty_flush(tp, flags);
! 475: break;
! 476: case TIOCSTART:
! 477: if (tp->t_state & TS_TTSTOP) {
! 478: tp->t_state &= ~TS_TTSTOP;
! 479: tty_start(tp);
! 480: }
! 481: break;
! 482: case TIOCSTOP:
! 483: if (!(tp->t_state & TS_TTSTOP)) {
! 484: tp->t_state |= TS_TTSTOP;
! 485: }
! 486: break;
! 487: case TIOCGWINSZ:
! 488: if (umem_copyout(&tp->t_winsize, data,
! 489: sizeof(struct winsize)))
! 490: return EFAULT;
! 491: break;
! 492: case TIOCSWINSZ:
! 493: if (umem_copyin(&tp->t_winsize, data,
! 494: sizeof(struct winsize)))
! 495: return EFAULT;
! 496: break;
! 497: case TIOCSETSIGT:
! 498: if (umem_copyin(data, &sig_task, sizeof(task_t)))
! 499: return EFAULT;
! 500: break;
! 501: }
! 502: return 0;
! 503: }
! 504:
! 505: /*
! 506: * Register tty device.
! 507: */
! 508: int
! 509: tty_register(struct devio *io, struct tty *tp, void (*output)(struct tty*))
! 510: {
! 511:
! 512: /* We support only one tty device */
! 513: if (tty_dev != NULL_DEVICE)
! 514: return -1;
! 515:
! 516: /* Create TTY device as an alias of the registered device. */
! 517: tty_dev = device_create(io, "tty", DF_CHR);
! 518: if (tty_dev == NULL_DEVICE)
! 519: return -1;
! 520:
! 521: /* Initialize tty */
! 522: memset(tp, 0, sizeof(struct tty));
! 523: memcpy(&tp->t_termios.c_cc, ttydefchars, sizeof(ttydefchars));
! 524: event_init(&tp->t_input_event, "TTY input");
! 525: tp->t_iflag = TTYDEF_IFLAG;
! 526: tp->t_oflag = TTYDEF_OFLAG;
! 527: tp->t_cflag = TTYDEF_CFLAG;
! 528: tp->t_lflag = TTYDEF_LFLAG;
! 529: tp->t_ispeed = TTYDEF_SPEED;
! 530: tp->t_ospeed = TTYDEF_SPEED;
! 531: tp->t_output = output;
! 532: return 0;
! 533: }
! 534:
! 535: /*
! 536: * Init
! 537: */
! 538: static int
! 539: tty_init(void)
! 540: {
! 541:
! 542: return 0;
! 543: }