sys/kern/subr_terminal.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  * Copyright (c) 2009 The FreeBSD Foundation
   5  * All rights reserved.
   6  *
   7  * This software was developed by Ed Schouten under sponsorship from the
   8  * FreeBSD Foundation.
   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  *
  19  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  29  * SUCH DAMAGE.
  30  */
  31
  32 #include <sys/cdefs.h>
  33 __FBSDID("$FreeBSD$");
  34
  35 #include <sys/param.h>
  36 #include <sys/cons.h>
  37 #include <sys/consio.h>
  38 #include <sys/kernel.h>
  39 #include <sys/lock.h>
  40 #include <sys/malloc.h>
  41 #include <sys/mutex.h>
  42 #include <sys/systm.h>
  43 #include <sys/terminal.h>
  44 #include <sys/tty.h>
  45
  46 #include <machine/stdarg.h>
  47
  48 static MALLOC_DEFINE(M_TERMINAL, "terminal", "terminal device");
  49
  50 /*
  51  * Locking.
  52  *
  53  * Normally we don't need to lock down the terminal emulator, because
  54  * the TTY lock is already held when calling teken_input().
  55  * Unfortunately this is not the case when the terminal acts as a
  56  * console device, because cnputc() can be called at the same time.
  57  * This means terminals may need to be locked down using a spin lock.
  58  */
  59 #define TERMINAL_LOCK(tm)       do {                                    \
  60         if ((tm)->tm_flags & TF_CONS)                                   \
  61                 mtx_lock_spin(&(tm)->tm_mtx);                           \
  62         else if ((tm)->tm_tty != NULL)                                  \
  63                 tty_lock((tm)->tm_tty);                                 \
  64 } while (0)
  65 #define TERMINAL_UNLOCK(tm)     do {                                    \
  66         if ((tm)->tm_flags & TF_CONS)                                   \
  67                 mtx_unlock_spin(&(tm)->tm_mtx);                         \
  68         else if ((tm)->tm_tty != NULL)                                  \
  69                 tty_unlock((tm)->tm_tty);                               \
  70 } while (0)
  71 #define TERMINAL_LOCK_TTY(tm)   do {                                    \
  72         if ((tm)->tm_flags & TF_CONS)                                   \
  73                 mtx_lock_spin(&(tm)->tm_mtx);                           \
  74 } while (0)
  75 #define TERMINAL_UNLOCK_TTY(tm) do {                                    \
  76         if ((tm)->tm_flags & TF_CONS)                                   \
  77                 mtx_unlock_spin(&(tm)->tm_mtx);                         \
  78 } while (0)
  79 #define TERMINAL_LOCK_CONS(tm)          mtx_lock_spin(&(tm)->tm_mtx)
  80 #define TERMINAL_UNLOCK_CONS(tm)        mtx_unlock_spin(&(tm)->tm_mtx)
  81
  82 /*
  83  * TTY routines.
  84  */
  85
  86 static tsw_open_t       termtty_open;
  87 static tsw_close_t      termtty_close;
  88 static tsw_outwakeup_t  termtty_outwakeup;
  89 static tsw_ioctl_t      termtty_ioctl;
  90 static tsw_mmap_t       termtty_mmap;
  91
  92 static struct ttydevsw terminal_tty_class = {
  93         .tsw_open       = termtty_open,
  94         .tsw_close      = termtty_close,
  95         .tsw_outwakeup  = termtty_outwakeup,
  96         .tsw_ioctl      = termtty_ioctl,
  97         .tsw_mmap       = termtty_mmap,
  98 };
  99
 100 /*
 101  * Terminal emulator routines.
 102  */
 103
 104 static tf_bell_t        termteken_bell;
 105 static tf_cursor_t      termteken_cursor;
 106 static tf_putchar_t     termteken_putchar;
 107 static tf_fill_t        termteken_fill;
 108 static tf_copy_t        termteken_copy;
 109 static tf_pre_input_t   termteken_pre_input;
 110 static tf_post_input_t  termteken_post_input;
 111 static tf_param_t       termteken_param;
 112 static tf_respond_t     termteken_respond;
 113
 114 static teken_funcs_t terminal_drawmethods = {
 115         .tf_bell        = termteken_bell,
 116         .tf_cursor      = termteken_cursor,
 117         .tf_putchar     = termteken_putchar,
 118         .tf_fill        = termteken_fill,
 119         .tf_copy        = termteken_copy,
 120         .tf_pre_input   = termteken_pre_input,
 121         .tf_post_input  = termteken_post_input,
 122         .tf_param       = termteken_param,
 123         .tf_respond     = termteken_respond,
 124 };
 125
 126 /* Kernel message formatting. */
 127 static teken_attr_t kernel_message = {
 128         .ta_fgcolor     = TCHAR_FGCOLOR(TERMINAL_KERN_ATTR),
 129         .ta_bgcolor     = TCHAR_BGCOLOR(TERMINAL_KERN_ATTR),
 130         .ta_format      = TCHAR_FORMAT(TERMINAL_KERN_ATTR)
 131 };
 132
 133 static teken_attr_t default_message = {
 134         .ta_fgcolor     = TCHAR_FGCOLOR(TERMINAL_NORM_ATTR),
 135         .ta_bgcolor     = TCHAR_BGCOLOR(TERMINAL_NORM_ATTR),
 136         .ta_format      = TCHAR_FORMAT(TERMINAL_NORM_ATTR)
 137 };
 138
 139 /* Fudge fg brightness as TF_BOLD (shifted). */
 140 #define TCOLOR_FG_FUDGED(color) __extension__ ({                        \
 141         teken_color_t _c;                                               \
 142                                                                         \
 143         _c = (color);                                                   \
 144         TCOLOR_FG(_c & 7) | ((_c & 8) << 18);                           \
 145 })
 146
 147 /* Fudge bg brightness as TF_BLINK (shifted). */
 148 #define TCOLOR_BG_FUDGED(color) __extension__ ({                        \
 149         teken_color_t _c;                                               \
 150                                                                         \
 151         _c = (color);                                                   \
 152         TCOLOR_BG(_c & 7) | ((_c & 8) << 20);                           \
 153 })
 154
 155 #define TCOLOR_256TO16(color) __extension__ ({                          \
 156         teken_color_t _c;                                               \
 157                                                                         \
 158         _c = (color);                                                   \
 159         if (_c >= 16)                                                   \
 160                 _c = teken_256to16(_c);                                 \
 161         _c;                                                             \
 162 })
 163
 164 #define TCHAR_CREATE(c, a)      ((c) | TFORMAT((a)->ta_format) |        \
 165         TCOLOR_FG_FUDGED(TCOLOR_256TO16((a)->ta_fgcolor)) |             \
 166         TCOLOR_BG_FUDGED(TCOLOR_256TO16((a)->ta_bgcolor)))
 167
 168 static void
 169 terminal_init(struct terminal *tm)
 170 {
 171         int fg, bg;
 172
 173         if (tm->tm_flags & TF_CONS)
 174                 mtx_init(&tm->tm_mtx, "trmlck", NULL, MTX_SPIN);
 175
 176         teken_init(&tm->tm_emulator, &terminal_drawmethods, tm);
 177
 178         fg = bg = -1;
 179         TUNABLE_INT_FETCH("teken.fg_color", &fg);
 180         TUNABLE_INT_FETCH("teken.bg_color", &bg);
 181
 182         if (fg != -1) {
 183                 default_message.ta_fgcolor = fg;
 184                 kernel_message.ta_fgcolor = fg;
 185         }
 186         if (bg != -1) {
 187                 default_message.ta_bgcolor = bg;
 188                 kernel_message.ta_bgcolor = bg;
 189         }
 190
 191         if (default_message.ta_bgcolor == TC_WHITE) {
 192                 default_message.ta_bgcolor |= TC_LIGHT;
 193                 kernel_message.ta_bgcolor |= TC_LIGHT;
 194         }
 195
 196         if (default_message.ta_bgcolor == TC_BLACK &&
 197             default_message.ta_fgcolor < TC_NCOLORS)
 198                 kernel_message.ta_fgcolor |= TC_LIGHT;
 199         teken_set_defattr(&tm->tm_emulator, &default_message);
 200 }
 201
 202 struct terminal *
 203 terminal_alloc(const struct terminal_class *tc, void *softc)
 204 {
 205         struct terminal *tm;
 206
 207         tm = malloc(sizeof(struct terminal), M_TERMINAL, M_WAITOK|M_ZERO);
 208         terminal_init(tm);
 209
 210         tm->tm_class = tc;
 211         tm->tm_softc = softc;
 212
 213         return (tm);
 214 }
 215
 216 static void
 217 terminal_sync_ttysize(struct terminal *tm)
 218 {
 219         struct tty *tp;
 220
 221         tp = tm->tm_tty;
 222         if (tp == NULL)
 223                 return;
 224
 225         tty_lock(tp);
 226         tty_set_winsize(tp, &tm->tm_winsize);
 227         tty_unlock(tp);
 228 }
 229
 230 void
 231 terminal_maketty(struct terminal *tm, const char *fmt, ...)
 232 {
 233         struct tty *tp;
 234         char name[8];
 235         va_list ap;
 236
 237         va_start(ap, fmt);
 238         vsnrprintf(name, sizeof name, 32, fmt, ap);
 239         va_end(ap);
 240
 241         tp = tty_alloc(&terminal_tty_class, tm);
 242         tty_makedev(tp, NULL, "%s", name);
 243         tm->tm_tty = tp;
 244         terminal_sync_ttysize(tm);
 245 }
 246
 247 void
 248 terminal_set_cursor(struct terminal *tm, const term_pos_t *pos)
 249 {
 250
 251         teken_set_cursor(&tm->tm_emulator, pos);
 252 }
 253
 254 void
 255 terminal_set_winsize_blank(struct terminal *tm, const struct winsize *size,
 256     int blank, const term_attr_t *attr)
 257 {
 258         term_rect_t r;
 259
 260         tm->tm_winsize = *size;
 261
 262         r.tr_begin.tp_row = r.tr_begin.tp_col = 0;
 263         r.tr_end.tp_row = size->ws_row;
 264         r.tr_end.tp_col = size->ws_col;
 265
 266         TERMINAL_LOCK(tm);
 267         if (blank == 0)
 268                 teken_set_winsize_noreset(&tm->tm_emulator, &r.tr_end);
 269         else
 270                 teken_set_winsize(&tm->tm_emulator, &r.tr_end);
 271         TERMINAL_UNLOCK(tm);
 272
 273         if ((blank != 0) && !(tm->tm_flags & TF_MUTE))
 274                 tm->tm_class->tc_fill(tm, &r,
 275                     TCHAR_CREATE((teken_char_t)' ', attr));
 276
 277         terminal_sync_ttysize(tm);
 278 }
 279
 280 void
 281 terminal_set_winsize(struct terminal *tm, const struct winsize *size)
 282 {
 283
 284         terminal_set_winsize_blank(tm, size, 1,
 285             (const term_attr_t *)&default_message);
 286 }
 287
 288 /*
 289  * XXX: This function is a kludge.  Drivers like vt(4) need to
 290  * temporarily stop input when resizing, etc.  This should ideally be
 291  * handled within the driver.
 292  */
 293
 294 void
 295 terminal_mute(struct terminal *tm, int yes)
 296 {
 297
 298         TERMINAL_LOCK(tm);
 299         if (yes)
 300                 tm->tm_flags |= TF_MUTE;
 301         else
 302                 tm->tm_flags &= ~TF_MUTE;
 303         TERMINAL_UNLOCK(tm);
 304 }
 305
 306 void
 307 terminal_input_char(struct terminal *tm, term_char_t c)
 308 {
 309         struct tty *tp;
 310
 311         tp = tm->tm_tty;
 312         if (tp == NULL)
 313                 return;
 314
 315         /*
 316          * Strip off any attributes. Also ignore input of second part of
 317          * CJK fullwidth characters, as we don't want to return these
 318          * characters twice.
 319          */
 320         if (TCHAR_FORMAT(c) & TF_CJK_RIGHT)
 321                 return;
 322         c = TCHAR_CHARACTER(c);
 323
 324         tty_lock(tp);
 325         /*
 326          * Conversion to UTF-8.
 327          */
 328         if (c < 0x80) {
 329                 ttydisc_rint(tp, c, 0);
 330         } else if (c < 0x800) {
 331                 char str[2] = {
 332                         0xc0 | (c >> 6),
 333                         0x80 | (c & 0x3f)
 334                 };
 335
 336                 ttydisc_rint_simple(tp, str, sizeof str);
 337         } else if (c < 0x10000) {
 338                 char str[3] = {
 339                         0xe0 | (c >> 12),
 340                         0x80 | ((c >> 6) & 0x3f),
 341                         0x80 | (c & 0x3f)
 342                 };
 343
 344                 ttydisc_rint_simple(tp, str, sizeof str);
 345         } else {
 346                 char str[4] = {
 347                         0xf0 | (c >> 18),
 348                         0x80 | ((c >> 12) & 0x3f),
 349                         0x80 | ((c >> 6) & 0x3f),
 350                         0x80 | (c & 0x3f)
 351                 };
 352
 353                 ttydisc_rint_simple(tp, str, sizeof str);
 354         }
 355         ttydisc_rint_done(tp);
 356         tty_unlock(tp);
 357 }
 358
 359 void
 360 terminal_input_raw(struct terminal *tm, char c)
 361 {
 362         struct tty *tp;
 363
 364         tp = tm->tm_tty;
 365         if (tp == NULL)
 366                 return;
 367
 368         tty_lock(tp);
 369         ttydisc_rint(tp, c, 0);
 370         ttydisc_rint_done(tp);
 371         tty_unlock(tp);
 372 }
 373
 374 void
 375 terminal_input_special(struct terminal *tm, unsigned int k)
 376 {
 377         struct tty *tp;
 378         const char *str;
 379
 380         tp = tm->tm_tty;
 381         if (tp == NULL)
 382                 return;
 383
 384         str = teken_get_sequence(&tm->tm_emulator, k);
 385         if (str == NULL)
 386                 return;
 387
 388         tty_lock(tp);
 389         ttydisc_rint_simple(tp, str, strlen(str));
 390         ttydisc_rint_done(tp);
 391         tty_unlock(tp);
 392 }
 393
 394 /*
 395  * Binding with the TTY layer.
 396  */
 397
 398 static int
 399 termtty_open(struct tty *tp)
 400 {
 401         struct terminal *tm = tty_softc(tp);
 402
 403         tm->tm_class->tc_opened(tm, 1);
 404         return (0);
 405 }
 406
 407 static void
 408 termtty_close(struct tty *tp)
 409 {
 410         struct terminal *tm = tty_softc(tp);
 411
 412         tm->tm_class->tc_opened(tm, 0);
 413 }
 414
 415 static void
 416 termtty_outwakeup(struct tty *tp)
 417 {
 418         struct terminal *tm = tty_softc(tp);
 419         char obuf[128];
 420         size_t olen;
 421         unsigned int flags = 0;
 422
 423         while ((olen = ttydisc_getc(tp, obuf, sizeof obuf)) > 0) {
 424                 TERMINAL_LOCK_TTY(tm);
 425                 if (!(tm->tm_flags & TF_MUTE)) {
 426                         tm->tm_flags &= ~TF_BELL;
 427                         teken_input(&tm->tm_emulator, obuf, olen);
 428                         flags |= tm->tm_flags;
 429                 }
 430                 TERMINAL_UNLOCK_TTY(tm);
 431         }
 432
 433         TERMINAL_LOCK_TTY(tm);
 434         if (!(tm->tm_flags & TF_MUTE))
 435                 tm->tm_class->tc_done(tm);
 436         TERMINAL_UNLOCK_TTY(tm);
 437         if (flags & TF_BELL)
 438                 tm->tm_class->tc_bell(tm);
 439 }
 440
 441 static int
 442 termtty_ioctl(struct tty *tp, u_long cmd, caddr_t data, struct thread *td)
 443 {
 444         struct terminal *tm = tty_softc(tp);
 445         int error;
 446
 447         switch (cmd) {
 448         case CONS_GETINFO: {
 449                 vid_info_t *vi = (vid_info_t *)data;
 450                 const teken_pos_t *p;
 451                 int fg, bg;
 452
 453                 if (vi->size != sizeof(vid_info_t))
 454                         return (EINVAL);
 455
 456                 /* Already help the console driver by filling in some data. */
 457                 p = teken_get_cursor(&tm->tm_emulator);
 458                 vi->mv_row = p->tp_row;
 459                 vi->mv_col = p->tp_col;
 460
 461                 p = teken_get_winsize(&tm->tm_emulator);
 462                 vi->mv_rsz = p->tp_row;
 463                 vi->mv_csz = p->tp_col;
 464
 465                 teken_get_defattr_cons25(&tm->tm_emulator, &fg, &bg);
 466                 vi->mv_norm.fore = fg;
 467                 vi->mv_norm.back = bg;
 468                 /* XXX: keep vidcontrol happy; bold backgrounds. */
 469                 vi->mv_rev.fore = bg;
 470                 vi->mv_rev.back = fg & 0x7;
 471                 break;
 472         }
 473         }
 474
 475         /*
 476          * Unlike various other drivers, this driver will never
 477          * deallocate TTYs.  This means it's safe to temporarily unlock
 478          * the TTY when handling ioctls.
 479          */
 480         tty_unlock(tp);
 481         error = tm->tm_class->tc_ioctl(tm, cmd, data, td);
 482         tty_lock(tp);
 483         return (error);
 484 }
 485
 486 static int
 487 termtty_mmap(struct tty *tp, vm_ooffset_t offset, vm_paddr_t * paddr,
 488     int nprot, vm_memattr_t *memattr)
 489 {
 490         struct terminal *tm = tty_softc(tp);
 491
 492         return (tm->tm_class->tc_mmap(tm, offset, paddr, nprot, memattr));
 493 }
 494
 495 /*
 496  * Binding with the kernel and debug console.
 497  */
 498
 499 static cn_probe_t       termcn_cnprobe;
 500 static cn_init_t        termcn_cninit;
 501 static cn_term_t        termcn_cnterm;
 502 static cn_getc_t        termcn_cngetc;
 503 static cn_putc_t        termcn_cnputc;
 504 static cn_grab_t        termcn_cngrab;
 505 static cn_ungrab_t      termcn_cnungrab;
 506
 507 const struct consdev_ops termcn_cnops = {
 508         .cn_probe       = termcn_cnprobe,
 509         .cn_init        = termcn_cninit,
 510         .cn_term        = termcn_cnterm,
 511         .cn_getc        = termcn_cngetc,
 512         .cn_putc        = termcn_cnputc,
 513         .cn_grab        = termcn_cngrab,
 514         .cn_ungrab      = termcn_cnungrab,
 515 };
 516
 517 void
 518 termcn_cnregister(struct terminal *tm)
 519 {
 520         struct consdev *cp;
 521
 522         cp = tm->consdev;
 523         if (cp == NULL) {
 524                 cp = malloc(sizeof(struct consdev), M_TERMINAL,
 525                     M_WAITOK|M_ZERO);
 526                 cp->cn_ops = &termcn_cnops;
 527                 cp->cn_arg = tm;
 528                 cp->cn_pri = CN_INTERNAL;
 529                 sprintf(cp->cn_name, "ttyv0");
 530
 531                 tm->tm_flags = TF_CONS;
 532                 tm->consdev = cp;
 533
 534                 terminal_init(tm);
 535         }
 536
 537         /* Attach terminal as console. */
 538         cnadd(cp);
 539 }
 540
 541 static void
 542 termcn_cngrab(struct consdev *cp)
 543 {
 544         struct terminal *tm = cp->cn_arg;
 545
 546         tm->tm_class->tc_cngrab(tm);
 547 }
 548
 549 static void
 550 termcn_cnungrab(struct consdev *cp)
 551 {
 552         struct terminal *tm = cp->cn_arg;
 553
 554         tm->tm_class->tc_cnungrab(tm);
 555 }
 556
 557 static void
 558 termcn_cnprobe(struct consdev *cp)
 559 {
 560         struct terminal *tm = cp->cn_arg;
 561
 562         if (tm == NULL) {
 563                 cp->cn_pri = CN_DEAD;
 564                 return;
 565         }
 566
 567         tm->consdev = cp;
 568         terminal_init(tm);
 569
 570         tm->tm_class->tc_cnprobe(tm, cp);
 571 }
 572
 573 static void
 574 termcn_cninit(struct consdev *cp)
 575 {
 576
 577 }
 578
 579 static void
 580 termcn_cnterm(struct consdev *cp)
 581 {
 582
 583 }
 584
 585 static int
 586 termcn_cngetc(struct consdev *cp)
 587 {
 588         struct terminal *tm = cp->cn_arg;
 589
 590         return (tm->tm_class->tc_cngetc(tm));
 591 }
 592
 593 static void
 594 termcn_cnputc(struct consdev *cp, int c)
 595 {
 596         struct terminal *tm = cp->cn_arg;
 597         teken_attr_t backup;
 598         char cv = c;
 599
 600         TERMINAL_LOCK_CONS(tm);
 601         if (!(tm->tm_flags & TF_MUTE)) {
 602                 backup = *teken_get_curattr(&tm->tm_emulator);
 603                 teken_set_curattr(&tm->tm_emulator, &kernel_message);
 604                 teken_input(&tm->tm_emulator, &cv, 1);
 605                 teken_set_curattr(&tm->tm_emulator, &backup);
 606                 tm->tm_class->tc_done(tm);
 607         }
 608         TERMINAL_UNLOCK_CONS(tm);
 609 }
 610
 611 /*
 612  * Binding with the terminal emulator.
 613  */
 614
 615 static void
 616 termteken_bell(void *softc)
 617 {
 618         struct terminal *tm = softc;
 619
 620         tm->tm_flags |= TF_BELL;
 621 }
 622
 623 static void
 624 termteken_cursor(void *softc, const teken_pos_t *p)
 625 {
 626         struct terminal *tm = softc;
 627
 628         tm->tm_class->tc_cursor(tm, p);
 629 }
 630
 631 static void
 632 termteken_putchar(void *softc, const teken_pos_t *p, teken_char_t c,
 633     const teken_attr_t *a)
 634 {
 635         struct terminal *tm = softc;
 636
 637         tm->tm_class->tc_putchar(tm, p, TCHAR_CREATE(c, a));
 638 }
 639
 640 static void
 641 termteken_fill(void *softc, const teken_rect_t *r, teken_char_t c,
 642     const teken_attr_t *a)
 643 {
 644         struct terminal *tm = softc;
 645
 646         tm->tm_class->tc_fill(tm, r, TCHAR_CREATE(c, a));
 647 }
 648
 649 static void
 650 termteken_copy(void *softc, const teken_rect_t *r, const teken_pos_t *p)
 651 {
 652         struct terminal *tm = softc;
 653
 654         tm->tm_class->tc_copy(tm, r, p);
 655 }
 656
 657 static void
 658 termteken_pre_input(void *softc)
 659 {
 660         struct terminal *tm = softc;
 661
 662         tm->tm_class->tc_pre_input(tm);
 663 }
 664
 665 static void
 666 termteken_post_input(void *softc)
 667 {
 668         struct terminal *tm = softc;
 669
 670         tm->tm_class->tc_post_input(tm);
 671 }
 672
 673 static void
 674 termteken_param(void *softc, int cmd, unsigned int arg)
 675 {
 676         struct terminal *tm = softc;
 677
 678         tm->tm_class->tc_param(tm, cmd, arg);
 679 }
 680
 681 static void
 682 termteken_respond(void *softc, const void *buf, size_t len)
 683 {
 684 #if 0
 685         struct terminal *tm = softc;
 686         struct tty *tp;
 687
 688         /*
 689          * Only inject a response into the TTY if the data actually
 690          * originated from the TTY.
 691          *
 692          * XXX: This cannot be done right now.  The TTY could pick up
 693          * other locks.  It could also in theory cause loops, when the
 694          * TTY performs echoing of a command that generates even more
 695          * input.
 696          */
 697         tp = tm->tm_tty;
 698         if (tp == NULL)
 699                 return;
 700
 701         ttydisc_rint_simple(tp, buf, len);
 702         ttydisc_rint_done(tp);
 703 #endif
 704 }