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