1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 22 /* 23 * Copyright 2008 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 27 /* 28 * ANSI terminal emulator module; parse ANSI X3.64 escape sequences and 29 * the like. 30 * 31 * How Virtual Terminal Emulator Works: 32 * 33 * Every virtual terminal is associated with a tem_vt_state structure 34 * and maintains a virtual screen buffer in tvs_screen_buf, which contains 35 * all the characters which should be shown on the physical screen when 36 * the terminal is activated. There are also two other buffers, tvs_fg_buf 37 * and tvs_bg_buf, which track the foreground and background colors of the 38 * on screen characters 39 * 40 * Data written to a virtual terminal is composed of characters which 41 * should be displayed on the screen when this virtual terminal is 42 * activated, fg/bg colors of these characters, and other control 43 * information (escape sequence, etc). 44 * 45 * When data is passed to a virtual terminal it first is parsed for 46 * control information by tem_safe_parse(). Subsequently the character 47 * and color data are written to tvs_screen_buf, tvs_fg_buf, and 48 * tvs_bg_buf. They are saved in these buffers in order to refresh 49 * the screen when this terminal is activated. If the terminal is 50 * currently active, the data (characters and colors) are also written 51 * to the physical screen by invoking a callback function, 52 * tem_safe_text_callbacks() or tem_safe_pix_callbacks(). 53 * 54 * When rendering data to the framebuffer, if the framebuffer is in 55 * VIS_PIXEL mode, the character data will first be converted to pixel 56 * data using tem_safe_pix_bit2pix(), and then the pixels get displayed 57 * on the physical screen. We only store the character and color data in 58 * tem_vt_state since the bit2pix conversion only happens when actually 59 * rendering to the physical framebuffer. 60 */ 61 62 63 #include <sys/types.h> 64 #include <sys/file.h> 65 #include <sys/conf.h> 66 #include <sys/errno.h> 67 #include <sys/open.h> 68 #include <sys/cred.h> 69 #include <sys/kmem.h> 70 #include <sys/ascii.h> 71 #include <sys/consdev.h> 72 #include <sys/font.h> 73 #include <sys/fbio.h> 74 #include <sys/conf.h> 75 #include <sys/modctl.h> 76 #include <sys/strsubr.h> 77 #include <sys/stat.h> 78 #include <sys/visual_io.h> 79 #include <sys/mutex.h> 80 #include <sys/param.h> 81 #include <sys/debug.h> 82 #include <sys/cmn_err.h> 83 #include <sys/console.h> 84 #include <sys/ddi.h> 85 #include <sys/sunddi.h> 86 #include <sys/sunldi.h> 87 #include <sys/tem_impl.h> 88 #ifdef _HAVE_TEM_FIRMWARE 89 #include <sys/promif.h> 90 #endif /* _HAVE_TEM_FIRMWARE */ 91 #include <sys/consplat.h> 92 #include <sys/kd.h> 93 #include <sys/sysmacros.h> 94 #include <sys/note.h> 95 #include <sys/t_lock.h> 96 97 /* Terminal emulator internal helper functions */ 98 static void tems_setup_terminal(struct vis_devinit *, size_t, size_t); 99 static void tems_modechange_callback(struct vis_modechg_arg *, 100 struct vis_devinit *); 101 102 static void tems_reset_colormap(cred_t *, enum called_from); 103 104 static void tem_free_buf(struct tem_vt_state *); 105 static void tem_internal_init(struct tem_vt_state *, cred_t *, boolean_t, 106 boolean_t); 107 static void tems_get_initial_color(tem_color_t *pcolor); 108 109 /* 110 * Globals 111 */ 112 static ldi_ident_t term_li = NULL; 113 tem_state_t tems; /* common term info */ 114 _NOTE(MUTEX_PROTECTS_DATA(tems.ts_lock, tems)) 115 116 extern struct mod_ops mod_miscops; 117 118 static struct modlmisc modlmisc = { 119 &mod_miscops, /* modops */ 120 "ANSI Terminal Emulator", /* name */ 121 }; 122 123 static struct modlinkage modlinkage = { 124 MODREV_1, { (void *)&modlmisc, NULL } 125 }; 126 127 int 128 _init(void) 129 { 130 int ret; 131 ret = mod_install(&modlinkage); 132 if (ret != 0) 133 return (ret); 134 ret = ldi_ident_from_mod(&modlinkage, &term_li); 135 if (ret != 0) { 136 (void) mod_remove(&modlinkage); 137 return (ret); 138 } 139 140 mutex_init(&tems.ts_lock, (char *)NULL, MUTEX_DRIVER, NULL); 141 list_create(&tems.ts_list, sizeof (struct tem_vt_state), 142 offsetof(struct tem_vt_state, tvs_list_node)); 143 tems.ts_active = NULL; 144 145 return (0); 146 } 147 148 int 149 _fini() 150 { 151 int ret; 152 153 ret = mod_remove(&modlinkage); 154 if (ret == 0) { 155 ldi_ident_release(term_li); 156 term_li = NULL; 157 } 158 return (ret); 159 } 160 161 int 162 _info(struct modinfo *modinfop) 163 { 164 return (mod_info(&modlinkage, modinfop)); 165 } 166 167 static void 168 tem_add(struct tem_vt_state *tem) 169 { 170 ASSERT(MUTEX_HELD(&tems.ts_lock) && MUTEX_HELD(&tem->tvs_lock)); 171 172 list_insert_head(&tems.ts_list, tem); 173 } 174 175 static void 176 tem_rm(struct tem_vt_state *tem) 177 { 178 ASSERT(MUTEX_HELD(&tems.ts_lock) && MUTEX_HELD(&tem->tvs_lock)); 179 180 list_remove(&tems.ts_list, tem); 181 } 182 183 /* 184 * This is the main entry point to the module. It handles output requests 185 * during normal system operation, when (e.g.) mutexes are available. 186 */ 187 void 188 tem_write(tem_vt_state_t tem_arg, uchar_t *buf, ssize_t len, cred_t *credp) 189 { 190 struct tem_vt_state *tem = (struct tem_vt_state *)tem_arg; 191 192 mutex_enter(&tems.ts_lock); 193 mutex_enter(&tem->tvs_lock); 194 195 if (!tem->tvs_initialized) { 196 mutex_exit(&tem->tvs_lock); 197 mutex_exit(&tems.ts_lock); 198 return; 199 } 200 201 tem_safe_check_first_time(tem, credp, CALLED_FROM_NORMAL); 202 tem_safe_terminal_emulate(tem, buf, len, credp, CALLED_FROM_NORMAL); 203 204 mutex_exit(&tem->tvs_lock); 205 mutex_exit(&tems.ts_lock); 206 } 207 208 static void 209 tem_internal_init(struct tem_vt_state *ptem, cred_t *credp, 210 boolean_t init_color, boolean_t clear_screen) 211 { 212 unsigned i, j, width, height; 213 text_attr_t attr; 214 text_color_t fg; 215 text_color_t bg; 216 217 ASSERT(MUTEX_HELD(&tems.ts_lock) && MUTEX_HELD(&ptem->tvs_lock)); 218 219 if (tems.ts_display_mode == VIS_PIXEL) { 220 ptem->tvs_pix_data_size = tems.ts_pix_data_size; 221 ptem->tvs_pix_data = 222 kmem_alloc(ptem->tvs_pix_data_size, KM_SLEEP); 223 } 224 225 ptem->tvs_outbuf_size = tems.ts_c_dimension.width * 226 sizeof (*ptem->tvs_outbuf); 227 ptem->tvs_outbuf = kmem_alloc(ptem->tvs_outbuf_size, KM_SLEEP); 228 229 width = tems.ts_c_dimension.width; 230 height = tems.ts_c_dimension.height; 231 ptem->tvs_screen_history_size = height; 232 233 ptem->tvs_screen_buf_size = width * ptem->tvs_screen_history_size * 234 sizeof (*ptem->tvs_screen_buf); 235 ptem->tvs_screen_buf = kmem_alloc(ptem->tvs_screen_buf_size, KM_SLEEP); 236 ptem->tvs_screen_rows = kmem_alloc(ptem->tvs_screen_history_size * 237 sizeof (term_char_t *), KM_SLEEP); 238 239 tem_safe_reset_display(ptem, credp, CALLED_FROM_NORMAL, 240 clear_screen, init_color); 241 242 ptem->tvs_utf8_left = 0; 243 ptem->tvs_utf8_partial = 0; 244 245 /* Get default attributes and fill up the screen buffer. */ 246 tem_safe_get_attr(ptem, &fg, &bg, &attr, TEM_ATTR_SCREEN_REVERSE); 247 for (i = 0; i < ptem->tvs_screen_history_size; i++) { 248 ptem->tvs_screen_rows[i] = &ptem->tvs_screen_buf[i * width]; 249 250 for (j = 0; j < width; j++) { 251 ptem->tvs_screen_rows[i][j].tc_fg_color = fg; 252 ptem->tvs_screen_rows[i][j].tc_bg_color = bg; 253 ptem->tvs_screen_rows[i][j].tc_char = 254 TEM_ATTR(attr) | ' '; 255 256 } 257 } 258 259 ptem->tvs_initialized = B_TRUE; 260 } 261 262 boolean_t 263 tem_initialized(tem_vt_state_t tem_arg) 264 { 265 struct tem_vt_state *ptem = (struct tem_vt_state *)tem_arg; 266 boolean_t ret; 267 268 mutex_enter(&ptem->tvs_lock); 269 ret = ptem->tvs_initialized; 270 mutex_exit(&ptem->tvs_lock); 271 272 return (ret); 273 } 274 275 tem_vt_state_t 276 tem_init(cred_t *credp) 277 { 278 struct tem_vt_state *ptem; 279 280 ptem = kmem_zalloc(sizeof (struct tem_vt_state), KM_SLEEP); 281 mutex_init(&ptem->tvs_lock, (char *)NULL, MUTEX_DRIVER, NULL); 282 283 mutex_enter(&tems.ts_lock); 284 mutex_enter(&ptem->tvs_lock); 285 286 ptem->tvs_isactive = B_FALSE; 287 ptem->tvs_fbmode = KD_TEXT; 288 289 /* 290 * A tem is regarded as initialized only after tem_internal_init(), 291 * will be set at the end of tem_internal_init(). 292 */ 293 ptem->tvs_initialized = B_FALSE; 294 295 296 if (!tems.ts_initialized) { 297 /* 298 * Only happens during early console configuration. 299 */ 300 tem_add(ptem); 301 mutex_exit(&ptem->tvs_lock); 302 mutex_exit(&tems.ts_lock); 303 return ((tem_vt_state_t)ptem); 304 } 305 306 tem_internal_init(ptem, credp, B_TRUE, B_FALSE); 307 tem_add(ptem); 308 mutex_exit(&ptem->tvs_lock); 309 mutex_exit(&tems.ts_lock); 310 311 return ((tem_vt_state_t)ptem); 312 } 313 314 /* 315 * re-init the tem after video mode has changed and tems_info has 316 * been re-inited. The lock is already held. 317 */ 318 static void 319 tem_reinit(struct tem_vt_state *tem, boolean_t reset_display) 320 { 321 ASSERT(MUTEX_HELD(&tems.ts_lock) && MUTEX_HELD(&tem->tvs_lock)); 322 323 tem_free_buf(tem); /* only free virtual buffers */ 324 325 /* reserve color */ 326 tem_internal_init(tem, kcred, B_FALSE, reset_display); 327 } 328 329 static void 330 tem_free_buf(struct tem_vt_state *tem) 331 { 332 ASSERT(tem != NULL && MUTEX_HELD(&tem->tvs_lock)); 333 334 if (tem->tvs_outbuf != NULL) 335 kmem_free(tem->tvs_outbuf, tem->tvs_outbuf_size); 336 if (tem->tvs_pix_data != NULL) 337 kmem_free(tem->tvs_pix_data, tem->tvs_pix_data_size); 338 if (tem->tvs_screen_buf != NULL) 339 kmem_free(tem->tvs_screen_buf, tem->tvs_screen_buf_size); 340 if (tem->tvs_screen_rows != NULL) { 341 kmem_free(tem->tvs_screen_rows, tem->tvs_screen_history_size * 342 sizeof (term_char_t *)); 343 } 344 } 345 346 void 347 tem_destroy(tem_vt_state_t tem_arg, cred_t *credp) 348 { 349 struct tem_vt_state *tem = (struct tem_vt_state *)tem_arg; 350 351 mutex_enter(&tems.ts_lock); 352 mutex_enter(&tem->tvs_lock); 353 354 if (tem->tvs_isactive && tem->tvs_fbmode == KD_TEXT) 355 tem_safe_blank_screen(tem, credp, CALLED_FROM_NORMAL); 356 357 tem_free_buf(tem); 358 tem_rm(tem); 359 360 if (tems.ts_active == tem) 361 tems.ts_active = NULL; 362 363 mutex_exit(&tem->tvs_lock); 364 mutex_exit(&tems.ts_lock); 365 366 kmem_free(tem, sizeof (struct tem_vt_state)); 367 } 368 369 static int 370 tems_failed(cred_t *credp, boolean_t finish_ioctl) 371 { 372 int lyr_rval; 373 374 ASSERT(MUTEX_HELD(&tems.ts_lock)); 375 376 if (finish_ioctl) 377 (void) ldi_ioctl(tems.ts_hdl, VIS_DEVFINI, 0, 378 FWRITE|FKIOCTL, credp, &lyr_rval); 379 380 (void) ldi_close(tems.ts_hdl, NULL, credp); 381 tems.ts_hdl = NULL; 382 return (ENXIO); 383 } 384 385 /* 386 * only called once during boot 387 */ 388 int 389 tem_info_init(char *pathname, cred_t *credp) 390 { 391 int lyr_rval, ret; 392 struct vis_devinit temargs; 393 char *pathbuf; 394 size_t height = 0; 395 size_t width = 0; 396 struct tem_vt_state *p; 397 398 mutex_enter(&tems.ts_lock); 399 400 if (tems.ts_initialized) { 401 mutex_exit(&tems.ts_lock); 402 return (0); 403 } 404 405 /* 406 * Open the layered device using the devfs physical device name 407 * after adding the /devices prefix. 408 */ 409 pathbuf = kmem_alloc(MAXPATHLEN, KM_SLEEP); 410 (void) strcpy(pathbuf, "/devices"); 411 if (i_ddi_prompath_to_devfspath(pathname, 412 pathbuf + strlen("/devices")) != DDI_SUCCESS) { 413 cmn_err(CE_WARN, "terminal-emulator: path conversion error"); 414 kmem_free(pathbuf, MAXPATHLEN); 415 416 mutex_exit(&tems.ts_lock); 417 return (ENXIO); 418 } 419 if (ldi_open_by_name(pathbuf, FWRITE, credp, 420 &tems.ts_hdl, term_li) != 0) { 421 cmn_err(CE_WARN, "terminal-emulator: device path open error"); 422 kmem_free(pathbuf, MAXPATHLEN); 423 424 mutex_exit(&tems.ts_lock); 425 return (ENXIO); 426 } 427 kmem_free(pathbuf, MAXPATHLEN); 428 429 temargs.modechg_cb = (vis_modechg_cb_t)tems_modechange_callback; 430 temargs.modechg_arg = NULL; 431 432 /* 433 * Initialize the console and get the device parameters 434 */ 435 if (ldi_ioctl(tems.ts_hdl, VIS_DEVINIT, 436 (intptr_t)&temargs, FWRITE|FKIOCTL, credp, &lyr_rval) != 0) { 437 cmn_err(CE_WARN, "terminal emulator: Compatible fb not found"); 438 ret = tems_failed(credp, B_FALSE); 439 mutex_exit(&tems.ts_lock); 440 return (ret); 441 } 442 443 /* Make sure the fb driver and terminal emulator versions match */ 444 if (temargs.version != VIS_CONS_REV) { 445 cmn_err(CE_WARN, 446 "terminal emulator: VIS_CONS_REV %d (see sys/visual_io.h) " 447 "of console fb driver not supported", temargs.version); 448 ret = tems_failed(credp, B_TRUE); 449 mutex_exit(&tems.ts_lock); 450 return (ret); 451 } 452 453 if ((tems.ts_fb_polledio = temargs.polledio) == NULL) { 454 cmn_err(CE_WARN, "terminal emulator: fb doesn't support polled " 455 "I/O"); 456 ret = tems_failed(credp, B_TRUE); 457 mutex_exit(&tems.ts_lock); 458 return (ret); 459 } 460 461 /* other sanity checks */ 462 if (!((temargs.depth == 4) || (temargs.depth == 8) || 463 (temargs.depth == 15) || (temargs.depth == 16) || 464 (temargs.depth == 24) || (temargs.depth == 32))) { 465 cmn_err(CE_WARN, "terminal emulator: unsupported depth"); 466 ret = tems_failed(credp, B_TRUE); 467 mutex_exit(&tems.ts_lock); 468 return (ret); 469 } 470 471 if ((temargs.mode != VIS_TEXT) && (temargs.mode != VIS_PIXEL)) { 472 cmn_err(CE_WARN, "terminal emulator: unsupported mode"); 473 ret = tems_failed(credp, B_TRUE); 474 mutex_exit(&tems.ts_lock); 475 return (ret); 476 } 477 478 if ((temargs.mode == VIS_PIXEL) && plat_stdout_is_framebuffer()) 479 plat_tem_get_prom_size(&height, &width); 480 481 /* 482 * Initialize the common terminal emulator info 483 */ 484 tems_setup_terminal(&temargs, height, width); 485 486 tems_reset_colormap(credp, CALLED_FROM_NORMAL); 487 tems_get_initial_color(&tems.ts_init_color); 488 489 tems.ts_initialized = 1; /* initialization flag */ 490 491 for (p = list_head(&tems.ts_list); p != NULL; 492 p = list_next(&tems.ts_list, p)) { 493 mutex_enter(&p->tvs_lock); 494 tem_internal_init(p, credp, B_TRUE, B_FALSE); 495 if (temargs.mode == VIS_PIXEL) 496 tem_pix_align(p, credp, CALLED_FROM_NORMAL); 497 mutex_exit(&p->tvs_lock); 498 } 499 500 mutex_exit(&tems.ts_lock); 501 return (0); 502 } 503 504 #define TEMS_DEPTH_DIFF 0x01 505 #define TEMS_DIMENSION_DIFF 0x02 506 507 static uchar_t 508 tems_check_videomode(struct vis_devinit *tp) 509 { 510 uchar_t result = 0; 511 512 if (tems.ts_pdepth != tp->depth) 513 result |= TEMS_DEPTH_DIFF; 514 515 if (tp->mode == VIS_TEXT) { 516 if (tems.ts_c_dimension.width != tp->width || 517 tems.ts_c_dimension.height != tp->height) 518 result |= TEMS_DIMENSION_DIFF; 519 } else { 520 if (tems.ts_p_dimension.width != tp->width || 521 tems.ts_p_dimension.height != tp->height) 522 result |= TEMS_DIMENSION_DIFF; 523 } 524 525 return (result); 526 } 527 528 static void 529 tems_setup_terminal(struct vis_devinit *tp, size_t height, size_t width) 530 { 531 bitmap_data_t *font_data; 532 int i; 533 int old_blank_buf_size = tems.ts_c_dimension.width * 534 sizeof (*tems.ts_blank_line); 535 536 ASSERT(MUTEX_HELD(&tems.ts_lock)); 537 538 tems.ts_pdepth = tp->depth; 539 tems.ts_linebytes = tp->linebytes; 540 tems.ts_display_mode = tp->mode; 541 tems.ts_color_map = tp->color_map; 542 543 switch (tp->mode) { 544 case VIS_TEXT: 545 tems.ts_p_dimension.width = 0; 546 tems.ts_p_dimension.height = 0; 547 tems.ts_c_dimension.width = tp->width; 548 tems.ts_c_dimension.height = tp->height; 549 tems.ts_callbacks = &tem_safe_text_callbacks; 550 551 break; 552 553 case VIS_PIXEL: 554 /* 555 * First check to see if the user has specified a screen size. 556 * If so, use those values. Else use 34x80 as the default. 557 */ 558 if (width == 0) { 559 width = TEM_DEFAULT_COLS; 560 height = TEM_DEFAULT_ROWS; 561 } 562 tems.ts_c_dimension.height = (screen_size_t)height; 563 tems.ts_c_dimension.width = (screen_size_t)width; 564 565 tems.ts_p_dimension.height = tp->height; 566 tems.ts_p_dimension.width = tp->width; 567 568 tems.ts_callbacks = &tem_safe_pix_callbacks; 569 570 /* 571 * set_font() will select a appropriate sized font for 572 * the number of rows and columns selected. If we don't 573 * have a font that will fit, then it will use the 574 * default builtin font. set_font() will adjust the rows 575 * and columns to fit on the screen. 576 */ 577 font_data = set_font(&tems.ts_c_dimension.height, 578 &tems.ts_c_dimension.width, 579 tems.ts_p_dimension.height, 580 tems.ts_p_dimension.width); 581 582 for (i = 0; i < VFNT_MAPS; i++) { 583 tems.ts_font.vf_map[i] = 584 font_data->font->vf_map[i]; 585 tems.ts_font.vf_map_count[i] = 586 font_data->font->vf_map_count[i]; 587 } 588 tems.ts_font.vf_bytes = font_data->font->vf_bytes; 589 tems.ts_font.vf_width = font_data->font->vf_width; 590 tems.ts_font.vf_height = font_data->font->vf_height; 591 592 tems.ts_p_offset.y = (tems.ts_p_dimension.height - 593 (tems.ts_c_dimension.height * tems.ts_font.vf_height)) / 2; 594 tems.ts_p_offset.x = (tems.ts_p_dimension.width - 595 (tems.ts_c_dimension.width * tems.ts_font.vf_width)) / 2; 596 597 tems.ts_pix_data_size = 598 tems.ts_font.vf_width * tems.ts_font.vf_height; 599 600 tems.ts_pix_data_size *= 4; 601 602 tems.ts_pdepth = tp->depth; 603 604 break; 605 } 606 607 /* Now virtual cls also uses the blank_line buffer */ 608 if (tems.ts_blank_line) 609 kmem_free(tems.ts_blank_line, old_blank_buf_size); 610 611 tems.ts_blank_line = kmem_alloc(tems.ts_c_dimension.width * 612 sizeof (*tems.ts_blank_line), KM_SLEEP); 613 } 614 615 /* 616 * This is a callback function that we register with the frame 617 * buffer driver layered underneath. It gets invoked from 618 * the underlying frame buffer driver to reconfigure the terminal 619 * emulator to a new screen size and depth in conjunction with 620 * framebuffer videomode changes. 621 * Here we keep the foreground/background color and attributes, 622 * which may be different with the initial settings, so that 623 * the color won't change while the framebuffer videomode changes. 624 * And we also reset the kernel terminal emulator and clear the 625 * whole screen. 626 */ 627 /* ARGSUSED */ 628 void 629 tems_modechange_callback(struct vis_modechg_arg *arg, 630 struct vis_devinit *devinit) 631 { 632 uchar_t diff; 633 struct tem_vt_state *p; 634 tem_modechg_cb_t cb; 635 tem_modechg_cb_arg_t cb_arg; 636 637 ASSERT(!(list_is_empty(&tems.ts_list))); 638 639 mutex_enter(&tems.ts_lock); 640 641 /* 642 * currently only for pixel mode 643 */ 644 diff = tems_check_videomode(devinit); 645 if (diff == 0) { 646 mutex_exit(&tems.ts_lock); 647 return; 648 } 649 650 diff = diff & TEMS_DIMENSION_DIFF; 651 652 if (diff == 0) { 653 /* 654 * Only need to reinit the active tem. 655 */ 656 struct tem_vt_state *active = tems.ts_active; 657 tems.ts_pdepth = devinit->depth; 658 659 mutex_enter(&active->tvs_lock); 660 ASSERT(active->tvs_isactive); 661 tem_reinit(active, B_TRUE); 662 mutex_exit(&active->tvs_lock); 663 664 mutex_exit(&tems.ts_lock); 665 return; 666 } 667 668 tems_setup_terminal(devinit, tems.ts_c_dimension.height, 669 tems.ts_c_dimension.width); 670 671 for (p = list_head(&tems.ts_list); p != NULL; 672 p = list_next(&tems.ts_list, p)) { 673 mutex_enter(&p->tvs_lock); 674 tem_reinit(p, p->tvs_isactive); 675 mutex_exit(&p->tvs_lock); 676 } 677 678 679 if (tems.ts_modechg_cb == NULL) { 680 mutex_exit(&tems.ts_lock); 681 return; 682 } 683 684 cb = tems.ts_modechg_cb; 685 cb_arg = tems.ts_modechg_arg; 686 687 /* 688 * Release the lock while doing callback. 689 */ 690 mutex_exit(&tems.ts_lock); 691 cb(cb_arg); 692 } 693 694 /* 695 * This function is used to clear entire screen via the underlying framebuffer 696 * driver. 697 */ 698 int 699 tems_cls_layered(struct vis_consclear *pda, 700 cred_t *credp) 701 { 702 int rval; 703 704 (void) ldi_ioctl(tems.ts_hdl, VIS_CONSCLEAR, 705 (intptr_t)pda, FKIOCTL, credp, &rval); 706 return (rval); 707 } 708 709 /* 710 * This function is used to display a rectangular blit of data 711 * of a given size and location via the underlying framebuffer driver. 712 * The blit can be as small as a pixel or as large as the screen. 713 */ 714 void 715 tems_display_layered(struct vis_consdisplay *pda, 716 cred_t *credp) 717 { 718 int rval; 719 720 (void) ldi_ioctl(tems.ts_hdl, VIS_CONSDISPLAY, 721 (intptr_t)pda, FKIOCTL, credp, &rval); 722 } 723 724 /* 725 * This function is used to invoke a block copy operation in the 726 * underlying framebuffer driver. Rectangle copies are how scrolling 727 * is implemented, as well as horizontal text shifting escape seqs. 728 * such as from vi when deleting characters and words. 729 */ 730 void 731 tems_copy_layered(struct vis_conscopy *pma, 732 cred_t *credp) 733 { 734 int rval; 735 736 (void) ldi_ioctl(tems.ts_hdl, VIS_CONSCOPY, 737 (intptr_t)pma, FKIOCTL, credp, &rval); 738 } 739 740 /* 741 * This function is used to show or hide a rectangluar monochrom 742 * pixel inverting, text block cursor via the underlying framebuffer. 743 */ 744 void 745 tems_cursor_layered(struct vis_conscursor *pca, 746 cred_t *credp) 747 { 748 int rval; 749 750 (void) ldi_ioctl(tems.ts_hdl, VIS_CONSCURSOR, 751 (intptr_t)pca, FKIOCTL, credp, &rval); 752 } 753 754 static void 755 tem_kdsetmode(int mode, cred_t *credp) 756 { 757 int rval; 758 759 (void) ldi_ioctl(tems.ts_hdl, KDSETMODE, 760 (intptr_t)mode, FKIOCTL, credp, &rval); 761 762 } 763 764 static void 765 tems_reset_colormap(cred_t *credp, enum called_from called_from) 766 { 767 struct vis_cmap cm; 768 int rval; 769 770 if (called_from == CALLED_FROM_STANDALONE) 771 return; 772 773 switch (tems.ts_pdepth) { 774 case 8: 775 cm.index = 0; 776 cm.count = 16; 777 cm.red = (uint8_t *)cmap4_to_24.red; 778 cm.blue = (uint8_t *)cmap4_to_24.blue; 779 cm.green = (uint8_t *)cmap4_to_24.green; 780 (void) ldi_ioctl(tems.ts_hdl, VIS_PUTCMAP, (intptr_t)&cm, 781 FKIOCTL, credp, &rval); 782 break; 783 } 784 } 785 786 void 787 tem_get_size(ushort_t *r, ushort_t *c, ushort_t *x, ushort_t *y) 788 { 789 mutex_enter(&tems.ts_lock); 790 *r = (ushort_t)tems.ts_c_dimension.height; 791 *c = (ushort_t)tems.ts_c_dimension.width; 792 *x = (ushort_t)tems.ts_p_dimension.width; 793 *y = (ushort_t)tems.ts_p_dimension.height; 794 mutex_exit(&tems.ts_lock); 795 } 796 797 void 798 tem_register_modechg_cb(tem_modechg_cb_t func, tem_modechg_cb_arg_t arg) 799 { 800 mutex_enter(&tems.ts_lock); 801 802 tems.ts_modechg_cb = func; 803 tems.ts_modechg_arg = arg; 804 805 mutex_exit(&tems.ts_lock); 806 } 807 808 /* 809 * This function is to scroll up the OBP output, which has 810 * different screen height and width with our kernel console. 811 */ 812 static void 813 tem_prom_scroll_up(struct tem_vt_state *tem, int nrows, cred_t *credp, 814 enum called_from called_from) 815 { 816 struct vis_conscopy ma; 817 int ncols, width; 818 819 /* copy */ 820 ma.s_row = nrows * tems.ts_font.vf_height; 821 ma.e_row = tems.ts_p_dimension.height - 1; 822 ma.t_row = 0; 823 824 ma.s_col = 0; 825 ma.e_col = tems.ts_p_dimension.width - 1; 826 ma.t_col = 0; 827 828 tems_safe_copy(&ma, credp, called_from); 829 830 /* clear */ 831 width = tems.ts_font.vf_width; 832 ncols = (tems.ts_p_dimension.width + (width - 1))/ width; 833 834 tem_safe_pix_cls_range(tem, 0, nrows, tems.ts_p_offset.y, 835 0, ncols, 0, B_TRUE, credp, called_from); 836 } 837 838 #define PROM_DEFAULT_FONT_HEIGHT 22 839 #define PROM_DEFAULT_WINDOW_TOP 0x8a 840 841 /* 842 * This function is to compute the starting row of the console, according to 843 * PROM cursor's position. Here we have to take different fonts into account. 844 */ 845 static int 846 tem_adjust_row(struct tem_vt_state *tem, int prom_row, cred_t *credp, 847 enum called_from called_from) 848 { 849 int tem_row; 850 int tem_y; 851 int prom_charheight = 0; 852 int prom_window_top = 0; 853 int scroll_up_lines; 854 855 plat_tem_get_prom_font_size(&prom_charheight, &prom_window_top); 856 if (prom_charheight == 0) 857 prom_charheight = PROM_DEFAULT_FONT_HEIGHT; 858 if (prom_window_top == 0) 859 prom_window_top = PROM_DEFAULT_WINDOW_TOP; 860 861 tem_y = (prom_row + 1) * prom_charheight + prom_window_top - 862 tems.ts_p_offset.y; 863 tem_row = (tem_y + tems.ts_font.vf_height - 1) / 864 tems.ts_font.vf_height - 1; 865 866 if (tem_row < 0) { 867 tem_row = 0; 868 } else if (tem_row >= (tems.ts_c_dimension.height - 1)) { 869 /* 870 * Scroll up the prom outputs if the PROM cursor's position is 871 * below our tem's lower boundary. 872 */ 873 scroll_up_lines = tem_row - 874 (tems.ts_c_dimension.height - 1); 875 tem_prom_scroll_up(tem, scroll_up_lines, credp, called_from); 876 tem_row = tems.ts_c_dimension.height - 1; 877 } 878 879 return (tem_row); 880 } 881 882 void 883 tem_pix_align(struct tem_vt_state *tem, cred_t *credp, 884 enum called_from called_from) 885 { 886 uint32_t row = 0; 887 uint32_t col = 0; 888 889 if (plat_stdout_is_framebuffer()) { 890 plat_tem_hide_prom_cursor(); 891 892 /* 893 * We are getting the current cursor position in pixel 894 * mode so that we don't over-write the console output 895 * during boot. 896 */ 897 plat_tem_get_prom_pos(&row, &col); 898 899 /* 900 * Adjust the row if necessary when the font of our 901 * kernel console tem is different with that of prom 902 * tem. 903 */ 904 row = tem_adjust_row(tem, row, credp, called_from); 905 906 /* first line of our kernel console output */ 907 tem->tvs_first_line = row + 1; 908 909 /* re-set and align cusror position */ 910 tem->tvs_s_cursor.row = tem->tvs_c_cursor.row = 911 (screen_pos_t)row; 912 tem->tvs_s_cursor.col = tem->tvs_c_cursor.col = 0; 913 } else { 914 tem_safe_reset_display(tem, credp, called_from, B_TRUE, B_TRUE); 915 } 916 } 917 918 static void 919 tems_get_inverses(boolean_t *p_inverse, boolean_t *p_inverse_screen) 920 { 921 int i_inverse = 0; 922 int i_inverse_screen = 0; 923 924 plat_tem_get_inverses(&i_inverse, &i_inverse_screen); 925 926 *p_inverse = (i_inverse == 0) ? B_FALSE : B_TRUE; 927 *p_inverse_screen = (i_inverse_screen == 0) ? B_FALSE : B_TRUE; 928 } 929 930 /* 931 * Get the foreground/background color and attributes from the initial 932 * PROM, so that our kernel console can keep the same visual behaviour. 933 */ 934 static void 935 tems_get_initial_color(tem_color_t *pcolor) 936 { 937 boolean_t inverse, inverse_screen; 938 unsigned short flags = 0; 939 940 pcolor->fg_color = DEFAULT_ANSI_FOREGROUND; 941 pcolor->bg_color = DEFAULT_ANSI_BACKGROUND; 942 #ifndef _HAVE_TEM_FIRMWARE 943 /* 944 * _HAVE_TEM_FIRMWARE is defined on SPARC, at this time, the 945 * plat_tem_get_colors() is implemented only on x86. 946 */ 947 plat_tem_get_colors(&pcolor->fg_color, &pcolor->bg_color); 948 #endif 949 950 tems_get_inverses(&inverse, &inverse_screen); 951 if (inverse) 952 flags |= TEM_ATTR_REVERSE; 953 if (inverse_screen) 954 flags |= TEM_ATTR_SCREEN_REVERSE; 955 956 if (flags != 0) { 957 /* 958 * If either reverse flag is set, the screen is in 959 * white-on-black mode. We set the bold flag to 960 * improve readability. 961 */ 962 flags |= TEM_ATTR_BOLD; 963 } else { 964 /* 965 * Otherwise, the screen is in black-on-white mode. 966 * The SPARC PROM console, which starts in this mode, 967 * uses the bright white background colour so we 968 * match it here. 969 */ 970 if (pcolor->bg_color == ANSI_COLOR_WHITE) 971 flags |= TEM_ATTR_BRIGHT_BG; 972 } 973 974 pcolor->a_flags = flags; 975 } 976 977 uchar_t 978 tem_get_fbmode(tem_vt_state_t tem_arg) 979 { 980 struct tem_vt_state *tem = (struct tem_vt_state *)tem_arg; 981 982 uchar_t fbmode; 983 984 mutex_enter(&tem->tvs_lock); 985 fbmode = tem->tvs_fbmode; 986 mutex_exit(&tem->tvs_lock); 987 988 return (fbmode); 989 } 990 991 void 992 tem_set_fbmode(tem_vt_state_t tem_arg, uchar_t fbmode, cred_t *credp) 993 { 994 struct tem_vt_state *tem = (struct tem_vt_state *)tem_arg; 995 996 mutex_enter(&tems.ts_lock); 997 mutex_enter(&tem->tvs_lock); 998 999 if (fbmode == tem->tvs_fbmode) { 1000 mutex_exit(&tem->tvs_lock); 1001 mutex_exit(&tems.ts_lock); 1002 return; 1003 } 1004 1005 tem->tvs_fbmode = fbmode; 1006 1007 if (tem->tvs_isactive) { 1008 tem_kdsetmode(tem->tvs_fbmode, credp); 1009 if (fbmode == KD_TEXT) 1010 tem_safe_unblank_screen(tem, credp, CALLED_FROM_NORMAL); 1011 } 1012 1013 mutex_exit(&tem->tvs_lock); 1014 mutex_exit(&tems.ts_lock); 1015 } 1016 1017 void 1018 tem_activate(tem_vt_state_t tem_arg, boolean_t unblank, cred_t *credp) 1019 { 1020 struct tem_vt_state *tem = (struct tem_vt_state *)tem_arg; 1021 1022 mutex_enter(&tems.ts_lock); 1023 tems.ts_active = tem; 1024 1025 mutex_enter(&tem->tvs_lock); 1026 tem->tvs_isactive = B_TRUE; 1027 1028 tem_kdsetmode(tem->tvs_fbmode, credp); 1029 1030 if (unblank) 1031 tem_safe_unblank_screen(tem, credp, CALLED_FROM_NORMAL); 1032 1033 mutex_exit(&tem->tvs_lock); 1034 mutex_exit(&tems.ts_lock); 1035 } 1036 1037 void 1038 tem_switch(tem_vt_state_t tem_arg1, tem_vt_state_t tem_arg2, cred_t *credp) 1039 { 1040 struct tem_vt_state *cur = (struct tem_vt_state *)tem_arg1; 1041 struct tem_vt_state *tobe = (struct tem_vt_state *)tem_arg2; 1042 1043 mutex_enter(&tems.ts_lock); 1044 mutex_enter(&tobe->tvs_lock); 1045 mutex_enter(&cur->tvs_lock); 1046 1047 tems.ts_active = tobe; 1048 cur->tvs_isactive = B_FALSE; 1049 tobe->tvs_isactive = B_TRUE; 1050 1051 mutex_exit(&cur->tvs_lock); 1052 1053 if (cur->tvs_fbmode != tobe->tvs_fbmode) 1054 tem_kdsetmode(tobe->tvs_fbmode, credp); 1055 1056 if (tobe->tvs_fbmode == KD_TEXT) 1057 tem_safe_unblank_screen(tobe, credp, CALLED_FROM_NORMAL); 1058 1059 mutex_exit(&tobe->tvs_lock); 1060 mutex_exit(&tems.ts_lock); 1061 } 1062