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 int i, j; 213 int width, height; 214 int total; 215 text_color_t fg; 216 text_color_t bg; 217 size_t tc_size = sizeof (text_color_t); 218 219 ASSERT(MUTEX_HELD(&tems.ts_lock) && MUTEX_HELD(&ptem->tvs_lock)); 220 221 if (tems.ts_display_mode == VIS_PIXEL) { 222 ptem->tvs_pix_data_size = tems.ts_pix_data_size; 223 ptem->tvs_pix_data = 224 kmem_alloc(ptem->tvs_pix_data_size, KM_SLEEP); 225 } 226 227 ptem->tvs_outbuf_size = tems.ts_c_dimension.width * 228 sizeof (*ptem->tvs_outbuf); 229 ptem->tvs_outbuf = kmem_alloc(ptem->tvs_outbuf_size, KM_SLEEP); 230 231 width = tems.ts_c_dimension.width; 232 height = tems.ts_c_dimension.height; 233 ptem->tvs_screen_buf_size = width * height * 234 sizeof (*ptem->tvs_screen_buf); 235 ptem->tvs_screen_buf = kmem_alloc(ptem->tvs_screen_buf_size, KM_SLEEP); 236 237 total = width * height * tc_size; 238 ptem->tvs_fg_buf = (text_color_t *)kmem_alloc(total, KM_SLEEP); 239 ptem->tvs_bg_buf = (text_color_t *)kmem_alloc(total, KM_SLEEP); 240 ptem->tvs_color_buf_size = total; 241 242 tem_safe_reset_display(ptem, credp, CALLED_FROM_NORMAL, 243 clear_screen, init_color); 244 245 ptem->tvs_utf8_left = 0; 246 ptem->tvs_utf8_partial = 0; 247 248 tem_safe_get_color(ptem, &fg, &bg, TEM_ATTR_SCREEN_REVERSE); 249 for (i = 0; i < height; i++) 250 for (j = 0; j < width; j++) { 251 ptem->tvs_screen_buf[i * width + j] = ' '; 252 ptem->tvs_fg_buf[(i * width +j) * tc_size] = fg; 253 ptem->tvs_bg_buf[(i * width +j) * tc_size] = bg; 254 255 } 256 257 ptem->tvs_initialized = 1; 258 } 259 260 int 261 tem_initialized(tem_vt_state_t tem_arg) 262 { 263 struct tem_vt_state *ptem = (struct tem_vt_state *)tem_arg; 264 int ret; 265 266 mutex_enter(&ptem->tvs_lock); 267 ret = ptem->tvs_initialized; 268 mutex_exit(&ptem->tvs_lock); 269 270 return (ret); 271 } 272 273 tem_vt_state_t 274 tem_init(cred_t *credp) 275 { 276 struct tem_vt_state *ptem; 277 278 ptem = kmem_zalloc(sizeof (struct tem_vt_state), KM_SLEEP); 279 mutex_init(&ptem->tvs_lock, (char *)NULL, MUTEX_DRIVER, NULL); 280 281 mutex_enter(&tems.ts_lock); 282 mutex_enter(&ptem->tvs_lock); 283 284 ptem->tvs_isactive = B_FALSE; 285 ptem->tvs_fbmode = KD_TEXT; 286 287 /* 288 * A tem is regarded as initialized only after tem_internal_init(), 289 * will be set at the end of tem_internal_init(). 290 */ 291 ptem->tvs_initialized = 0; 292 293 294 if (!tems.ts_initialized) { 295 /* 296 * Only happens during early console configuration. 297 */ 298 tem_add(ptem); 299 mutex_exit(&ptem->tvs_lock); 300 mutex_exit(&tems.ts_lock); 301 return ((tem_vt_state_t)ptem); 302 } 303 304 tem_internal_init(ptem, credp, B_TRUE, B_FALSE); 305 tem_add(ptem); 306 mutex_exit(&ptem->tvs_lock); 307 mutex_exit(&tems.ts_lock); 308 309 return ((tem_vt_state_t)ptem); 310 } 311 312 /* 313 * re-init the tem after video mode has changed and tems_info has 314 * been re-inited. The lock is already held. 315 */ 316 static void 317 tem_reinit(struct tem_vt_state *tem, boolean_t reset_display) 318 { 319 ASSERT(MUTEX_HELD(&tems.ts_lock) && MUTEX_HELD(&tem->tvs_lock)); 320 321 tem_free_buf(tem); /* only free virtual buffers */ 322 323 /* reserve color */ 324 tem_internal_init(tem, kcred, B_FALSE, reset_display); 325 } 326 327 static void 328 tem_free_buf(struct tem_vt_state *tem) 329 { 330 ASSERT(tem != NULL && MUTEX_HELD(&tem->tvs_lock)); 331 332 if (tem->tvs_outbuf != NULL) 333 kmem_free(tem->tvs_outbuf, tem->tvs_outbuf_size); 334 if (tem->tvs_pix_data != NULL) 335 kmem_free(tem->tvs_pix_data, tem->tvs_pix_data_size); 336 if (tem->tvs_screen_buf != NULL) 337 kmem_free(tem->tvs_screen_buf, tem->tvs_screen_buf_size); 338 if (tem->tvs_fg_buf != NULL) 339 kmem_free(tem->tvs_fg_buf, tem->tvs_color_buf_size); 340 if (tem->tvs_bg_buf != NULL) 341 kmem_free(tem->tvs_bg_buf, tem->tvs_color_buf_size); 342 } 343 344 void 345 tem_destroy(tem_vt_state_t tem_arg, cred_t *credp) 346 { 347 struct tem_vt_state *tem = (struct tem_vt_state *)tem_arg; 348 349 mutex_enter(&tems.ts_lock); 350 mutex_enter(&tem->tvs_lock); 351 352 if (tem->tvs_isactive && tem->tvs_fbmode == KD_TEXT) 353 tem_safe_blank_screen(tem, credp, CALLED_FROM_NORMAL); 354 355 tem_free_buf(tem); 356 tem_rm(tem); 357 358 if (tems.ts_active == tem) 359 tems.ts_active = NULL; 360 361 mutex_exit(&tem->tvs_lock); 362 mutex_exit(&tems.ts_lock); 363 364 kmem_free(tem, sizeof (struct tem_vt_state)); 365 } 366 367 static int 368 tems_failed(cred_t *credp, boolean_t finish_ioctl) 369 { 370 int lyr_rval; 371 372 ASSERT(MUTEX_HELD(&tems.ts_lock)); 373 374 if (finish_ioctl) 375 (void) ldi_ioctl(tems.ts_hdl, VIS_DEVFINI, 0, 376 FWRITE|FKIOCTL, credp, &lyr_rval); 377 378 (void) ldi_close(tems.ts_hdl, NULL, credp); 379 tems.ts_hdl = NULL; 380 return (ENXIO); 381 } 382 383 /* 384 * only called once during boot 385 */ 386 int 387 tem_info_init(char *pathname, cred_t *credp) 388 { 389 int lyr_rval, ret; 390 struct vis_devinit temargs; 391 char *pathbuf; 392 size_t height = 0; 393 size_t width = 0; 394 struct tem_vt_state *p; 395 396 mutex_enter(&tems.ts_lock); 397 398 if (tems.ts_initialized) { 399 mutex_exit(&tems.ts_lock); 400 return (0); 401 } 402 403 /* 404 * Open the layered device using the devfs physical device name 405 * after adding the /devices prefix. 406 */ 407 pathbuf = kmem_alloc(MAXPATHLEN, KM_SLEEP); 408 (void) strcpy(pathbuf, "/devices"); 409 if (i_ddi_prompath_to_devfspath(pathname, 410 pathbuf + strlen("/devices")) != DDI_SUCCESS) { 411 cmn_err(CE_WARN, "terminal-emulator: path conversion error"); 412 kmem_free(pathbuf, MAXPATHLEN); 413 414 mutex_exit(&tems.ts_lock); 415 return (ENXIO); 416 } 417 if (ldi_open_by_name(pathbuf, FWRITE, credp, 418 &tems.ts_hdl, term_li) != 0) { 419 cmn_err(CE_WARN, "terminal-emulator: device path open error"); 420 kmem_free(pathbuf, MAXPATHLEN); 421 422 mutex_exit(&tems.ts_lock); 423 return (ENXIO); 424 } 425 kmem_free(pathbuf, MAXPATHLEN); 426 427 temargs.modechg_cb = (vis_modechg_cb_t)tems_modechange_callback; 428 temargs.modechg_arg = NULL; 429 430 /* 431 * Initialize the console and get the device parameters 432 */ 433 if (ldi_ioctl(tems.ts_hdl, VIS_DEVINIT, 434 (intptr_t)&temargs, FWRITE|FKIOCTL, credp, &lyr_rval) != 0) { 435 cmn_err(CE_WARN, "terminal emulator: Compatible fb not found"); 436 ret = tems_failed(credp, B_FALSE); 437 mutex_exit(&tems.ts_lock); 438 return (ret); 439 } 440 441 /* Make sure the fb driver and terminal emulator versions match */ 442 if (temargs.version != VIS_CONS_REV) { 443 cmn_err(CE_WARN, 444 "terminal emulator: VIS_CONS_REV %d (see sys/visual_io.h) " 445 "of console fb driver not supported", temargs.version); 446 ret = tems_failed(credp, B_TRUE); 447 mutex_exit(&tems.ts_lock); 448 return (ret); 449 } 450 451 if ((tems.ts_fb_polledio = temargs.polledio) == NULL) { 452 cmn_err(CE_WARN, "terminal emulator: fb doesn't support polled " 453 "I/O"); 454 ret = tems_failed(credp, B_TRUE); 455 mutex_exit(&tems.ts_lock); 456 return (ret); 457 } 458 459 /* other sanity checks */ 460 if (!((temargs.depth == 4) || (temargs.depth == 8) || 461 (temargs.depth == 15) || (temargs.depth == 16) || 462 (temargs.depth == 24) || (temargs.depth == 32))) { 463 cmn_err(CE_WARN, "terminal emulator: unsupported depth"); 464 ret = tems_failed(credp, B_TRUE); 465 mutex_exit(&tems.ts_lock); 466 return (ret); 467 } 468 469 if ((temargs.mode != VIS_TEXT) && (temargs.mode != VIS_PIXEL)) { 470 cmn_err(CE_WARN, "terminal emulator: unsupported mode"); 471 ret = tems_failed(credp, B_TRUE); 472 mutex_exit(&tems.ts_lock); 473 return (ret); 474 } 475 476 if ((temargs.mode == VIS_PIXEL) && plat_stdout_is_framebuffer()) 477 plat_tem_get_prom_size(&height, &width); 478 479 /* 480 * Initialize the common terminal emulator info 481 */ 482 tems_setup_terminal(&temargs, height, width); 483 484 tems_reset_colormap(credp, CALLED_FROM_NORMAL); 485 tems_get_initial_color(&tems.ts_init_color); 486 487 tems.ts_initialized = 1; /* initialization flag */ 488 489 for (p = list_head(&tems.ts_list); p != NULL; 490 p = list_next(&tems.ts_list, p)) { 491 mutex_enter(&p->tvs_lock); 492 tem_internal_init(p, credp, B_TRUE, B_FALSE); 493 if (temargs.mode == VIS_PIXEL) 494 tem_pix_align(p, credp, CALLED_FROM_NORMAL); 495 mutex_exit(&p->tvs_lock); 496 } 497 498 mutex_exit(&tems.ts_lock); 499 return (0); 500 } 501 502 #define TEMS_DEPTH_DIFF 0x01 503 #define TEMS_DIMENSION_DIFF 0x02 504 505 static uchar_t 506 tems_check_videomode(struct vis_devinit *tp) 507 { 508 uchar_t result = 0; 509 510 if (tems.ts_pdepth != tp->depth) 511 result |= TEMS_DEPTH_DIFF; 512 513 if (tp->mode == VIS_TEXT) { 514 if (tems.ts_c_dimension.width != tp->width || 515 tems.ts_c_dimension.height != tp->height) 516 result |= TEMS_DIMENSION_DIFF; 517 } else { 518 if (tems.ts_p_dimension.width != tp->width || 519 tems.ts_p_dimension.height != tp->height) 520 result |= TEMS_DIMENSION_DIFF; 521 } 522 523 return (result); 524 } 525 526 static void 527 tems_setup_terminal(struct vis_devinit *tp, size_t height, size_t width) 528 { 529 int i; 530 int old_blank_buf_size = tems.ts_c_dimension.width * 531 sizeof (*tems.ts_blank_line); 532 533 ASSERT(MUTEX_HELD(&tems.ts_lock)); 534 535 tems.ts_pdepth = tp->depth; 536 tems.ts_linebytes = tp->linebytes; 537 tems.ts_display_mode = tp->mode; 538 tems.ts_color_map = tp->color_map; 539 540 switch (tp->mode) { 541 case VIS_TEXT: 542 tems.ts_p_dimension.width = 0; 543 tems.ts_p_dimension.height = 0; 544 tems.ts_c_dimension.width = tp->width; 545 tems.ts_c_dimension.height = tp->height; 546 tems.ts_callbacks = &tem_safe_text_callbacks; 547 548 break; 549 550 case VIS_PIXEL: 551 /* 552 * First check to see if the user has specified a screen size. 553 * If so, use those values. Else use 34x80 as the default. 554 */ 555 if (width == 0) { 556 width = TEM_DEFAULT_COLS; 557 height = TEM_DEFAULT_ROWS; 558 } 559 tems.ts_c_dimension.height = (screen_size_t)height; 560 tems.ts_c_dimension.width = (screen_size_t)width; 561 562 tems.ts_p_dimension.height = tp->height; 563 tems.ts_p_dimension.width = tp->width; 564 565 tems.ts_callbacks = &tem_safe_pix_callbacks; 566 567 /* 568 * set_font() will select a appropriate sized font for 569 * the number of rows and columns selected. If we don't 570 * have a font that will fit, then it will use the 571 * default builtin font. set_font() will adjust the rows 572 * and columns to fit on the screen. 573 */ 574 set_font(&tems.ts_font, 575 &tems.ts_c_dimension.height, 576 &tems.ts_c_dimension.width, 577 tems.ts_p_dimension.height, 578 tems.ts_p_dimension.width); 579 580 tems.ts_p_offset.y = (tems.ts_p_dimension.height - 581 (tems.ts_c_dimension.height * tems.ts_font.height)) / 2; 582 tems.ts_p_offset.x = (tems.ts_p_dimension.width - 583 (tems.ts_c_dimension.width * tems.ts_font.width)) / 2; 584 585 tems.ts_pix_data_size = 586 tems.ts_font.width * tems.ts_font.height; 587 588 tems.ts_pix_data_size *= 4; 589 590 tems.ts_pdepth = tp->depth; 591 592 break; 593 } 594 595 /* Now virtual cls also uses the blank_line buffer */ 596 if (tems.ts_blank_line) 597 kmem_free(tems.ts_blank_line, old_blank_buf_size); 598 599 tems.ts_blank_line = 600 kmem_alloc(tems.ts_c_dimension.width * sizeof (*tems.ts_blank_line), 601 KM_SLEEP); 602 for (i = 0; i < tems.ts_c_dimension.width; i++) 603 tems.ts_blank_line[i] = ' '; 604 } 605 606 /* 607 * This is a callback function that we register with the frame 608 * buffer driver layered underneath. It gets invoked from 609 * the underlying frame buffer driver to reconfigure the terminal 610 * emulator to a new screen size and depth in conjunction with 611 * framebuffer videomode changes. 612 * Here we keep the foreground/background color and attributes, 613 * which may be different with the initial settings, so that 614 * the color won't change while the framebuffer videomode changes. 615 * And we also reset the kernel terminal emulator and clear the 616 * whole screen. 617 */ 618 /* ARGSUSED */ 619 void 620 tems_modechange_callback(struct vis_modechg_arg *arg, 621 struct vis_devinit *devinit) 622 { 623 uchar_t diff; 624 struct tem_vt_state *p; 625 tem_modechg_cb_t cb; 626 tem_modechg_cb_arg_t cb_arg; 627 628 ASSERT(!(list_is_empty(&tems.ts_list))); 629 630 mutex_enter(&tems.ts_lock); 631 632 /* 633 * currently only for pixel mode 634 */ 635 diff = tems_check_videomode(devinit); 636 if (diff == 0) { 637 mutex_exit(&tems.ts_lock); 638 return; 639 } 640 641 diff = diff & TEMS_DIMENSION_DIFF; 642 643 if (diff == 0) { 644 /* 645 * Only need to reinit the active tem. 646 */ 647 struct tem_vt_state *active = tems.ts_active; 648 tems.ts_pdepth = devinit->depth; 649 650 mutex_enter(&active->tvs_lock); 651 ASSERT(active->tvs_isactive); 652 tem_reinit(active, B_TRUE); 653 mutex_exit(&active->tvs_lock); 654 655 mutex_exit(&tems.ts_lock); 656 return; 657 } 658 659 tems_setup_terminal(devinit, tems.ts_c_dimension.height, 660 tems.ts_c_dimension.width); 661 662 for (p = list_head(&tems.ts_list); p != NULL; 663 p = list_next(&tems.ts_list, p)) { 664 mutex_enter(&p->tvs_lock); 665 tem_reinit(p, p->tvs_isactive); 666 mutex_exit(&p->tvs_lock); 667 } 668 669 670 if (tems.ts_modechg_cb == NULL) { 671 mutex_exit(&tems.ts_lock); 672 return; 673 } 674 675 cb = tems.ts_modechg_cb; 676 cb_arg = tems.ts_modechg_arg; 677 678 /* 679 * Release the lock while doing callback. 680 */ 681 mutex_exit(&tems.ts_lock); 682 cb(cb_arg); 683 } 684 685 /* 686 * This function is used to clear entire screen via the underlying framebuffer 687 * driver. 688 */ 689 int 690 tems_cls_layered(struct vis_consclear *pda, 691 cred_t *credp) 692 { 693 int rval; 694 695 (void) ldi_ioctl(tems.ts_hdl, VIS_CONSCLEAR, 696 (intptr_t)pda, FKIOCTL, credp, &rval); 697 return (rval); 698 } 699 700 /* 701 * This function is used to display a rectangular blit of data 702 * of a given size and location via the underlying framebuffer driver. 703 * The blit can be as small as a pixel or as large as the screen. 704 */ 705 void 706 tems_display_layered(struct vis_consdisplay *pda, 707 cred_t *credp) 708 { 709 int rval; 710 711 (void) ldi_ioctl(tems.ts_hdl, VIS_CONSDISPLAY, 712 (intptr_t)pda, FKIOCTL, credp, &rval); 713 } 714 715 /* 716 * This function is used to invoke a block copy operation in the 717 * underlying framebuffer driver. Rectangle copies are how scrolling 718 * is implemented, as well as horizontal text shifting escape seqs. 719 * such as from vi when deleting characters and words. 720 */ 721 void 722 tems_copy_layered(struct vis_conscopy *pma, 723 cred_t *credp) 724 { 725 int rval; 726 727 (void) ldi_ioctl(tems.ts_hdl, VIS_CONSCOPY, 728 (intptr_t)pma, FKIOCTL, credp, &rval); 729 } 730 731 /* 732 * This function is used to show or hide a rectangluar monochrom 733 * pixel inverting, text block cursor via the underlying framebuffer. 734 */ 735 void 736 tems_cursor_layered(struct vis_conscursor *pca, 737 cred_t *credp) 738 { 739 int rval; 740 741 (void) ldi_ioctl(tems.ts_hdl, VIS_CONSCURSOR, 742 (intptr_t)pca, FKIOCTL, credp, &rval); 743 } 744 745 static void 746 tem_kdsetmode(int mode, cred_t *credp) 747 { 748 int rval; 749 750 (void) ldi_ioctl(tems.ts_hdl, KDSETMODE, 751 (intptr_t)mode, FKIOCTL, credp, &rval); 752 753 } 754 755 static void 756 tems_reset_colormap(cred_t *credp, enum called_from called_from) 757 { 758 struct vis_cmap cm; 759 int rval; 760 761 if (called_from == CALLED_FROM_STANDALONE) 762 return; 763 764 switch (tems.ts_pdepth) { 765 case 8: 766 cm.index = 0; 767 cm.count = 16; 768 cm.red = cmap4_to_24.red; /* 8-bits (1/3 of TrueColor 24) */ 769 cm.blue = cmap4_to_24.blue; /* 8-bits (1/3 of TrueColor 24) */ 770 cm.green = cmap4_to_24.green; /* 8-bits (1/3 of TrueColor 24) */ 771 (void) ldi_ioctl(tems.ts_hdl, VIS_PUTCMAP, (intptr_t)&cm, 772 FKIOCTL, credp, &rval); 773 break; 774 } 775 } 776 777 void 778 tem_get_size(ushort_t *r, ushort_t *c, ushort_t *x, ushort_t *y) 779 { 780 mutex_enter(&tems.ts_lock); 781 *r = (ushort_t)tems.ts_c_dimension.height; 782 *c = (ushort_t)tems.ts_c_dimension.width; 783 *x = (ushort_t)tems.ts_p_dimension.width; 784 *y = (ushort_t)tems.ts_p_dimension.height; 785 mutex_exit(&tems.ts_lock); 786 } 787 788 void 789 tem_register_modechg_cb(tem_modechg_cb_t func, tem_modechg_cb_arg_t arg) 790 { 791 mutex_enter(&tems.ts_lock); 792 793 tems.ts_modechg_cb = func; 794 tems.ts_modechg_arg = arg; 795 796 mutex_exit(&tems.ts_lock); 797 } 798 799 /* 800 * This function is to scroll up the OBP output, which has 801 * different screen height and width with our kernel console. 802 */ 803 static void 804 tem_prom_scroll_up(struct tem_vt_state *tem, int nrows, cred_t *credp, 805 enum called_from called_from) 806 { 807 struct vis_conscopy ma; 808 int ncols, width; 809 810 /* copy */ 811 ma.s_row = nrows * tems.ts_font.height; 812 ma.e_row = tems.ts_p_dimension.height - 1; 813 ma.t_row = 0; 814 815 ma.s_col = 0; 816 ma.e_col = tems.ts_p_dimension.width - 1; 817 ma.t_col = 0; 818 819 tems_safe_copy(&ma, credp, called_from); 820 821 /* clear */ 822 width = tems.ts_font.width; 823 ncols = (tems.ts_p_dimension.width + (width - 1))/ width; 824 825 tem_safe_pix_cls_range(tem, 0, nrows, tems.ts_p_offset.y, 826 0, ncols, 0, B_TRUE, credp, called_from); 827 } 828 829 #define PROM_DEFAULT_FONT_HEIGHT 22 830 #define PROM_DEFAULT_WINDOW_TOP 0x8a 831 832 /* 833 * This function is to compute the starting row of the console, according to 834 * PROM cursor's position. Here we have to take different fonts into account. 835 */ 836 static int 837 tem_adjust_row(struct tem_vt_state *tem, int prom_row, cred_t *credp, 838 enum called_from called_from) 839 { 840 int tem_row; 841 int tem_y; 842 int prom_charheight = 0; 843 int prom_window_top = 0; 844 int scroll_up_lines; 845 846 plat_tem_get_prom_font_size(&prom_charheight, &prom_window_top); 847 if (prom_charheight == 0) 848 prom_charheight = PROM_DEFAULT_FONT_HEIGHT; 849 if (prom_window_top == 0) 850 prom_window_top = PROM_DEFAULT_WINDOW_TOP; 851 852 tem_y = (prom_row + 1) * prom_charheight + prom_window_top - 853 tems.ts_p_offset.y; 854 tem_row = (tem_y + tems.ts_font.height - 1) / 855 tems.ts_font.height - 1; 856 857 if (tem_row < 0) { 858 tem_row = 0; 859 } else if (tem_row >= (tems.ts_c_dimension.height - 1)) { 860 /* 861 * Scroll up the prom outputs if the PROM cursor's position is 862 * below our tem's lower boundary. 863 */ 864 scroll_up_lines = tem_row - 865 (tems.ts_c_dimension.height - 1); 866 tem_prom_scroll_up(tem, scroll_up_lines, credp, called_from); 867 tem_row = tems.ts_c_dimension.height - 1; 868 } 869 870 return (tem_row); 871 } 872 873 void 874 tem_pix_align(struct tem_vt_state *tem, cred_t *credp, 875 enum called_from called_from) 876 { 877 uint32_t row = 0; 878 uint32_t col = 0; 879 880 if (plat_stdout_is_framebuffer()) { 881 plat_tem_hide_prom_cursor(); 882 883 /* 884 * We are getting the current cursor position in pixel 885 * mode so that we don't over-write the console output 886 * during boot. 887 */ 888 plat_tem_get_prom_pos(&row, &col); 889 890 /* 891 * Adjust the row if necessary when the font of our 892 * kernel console tem is different with that of prom 893 * tem. 894 */ 895 row = tem_adjust_row(tem, row, credp, called_from); 896 897 /* first line of our kernel console output */ 898 tem->tvs_first_line = row + 1; 899 900 /* re-set and align cusror position */ 901 tem->tvs_s_cursor.row = tem->tvs_c_cursor.row = 902 (screen_pos_t)row; 903 tem->tvs_s_cursor.col = tem->tvs_c_cursor.col = 0; 904 } else { 905 tem_safe_reset_display(tem, credp, called_from, B_TRUE, B_TRUE); 906 } 907 } 908 909 static void 910 tems_get_inverses(boolean_t *p_inverse, boolean_t *p_inverse_screen) 911 { 912 int i_inverse = 0; 913 int i_inverse_screen = 0; 914 915 plat_tem_get_inverses(&i_inverse, &i_inverse_screen); 916 917 *p_inverse = (i_inverse == 0) ? B_FALSE : B_TRUE; 918 *p_inverse_screen = (i_inverse_screen == 0) ? B_FALSE : B_TRUE; 919 } 920 921 /* 922 * Get the foreground/background color and attributes from the initial 923 * PROM, so that our kernel console can keep the same visual behaviour. 924 */ 925 static void 926 tems_get_initial_color(tem_color_t *pcolor) 927 { 928 boolean_t inverse, inverse_screen; 929 unsigned short flags = 0; 930 931 pcolor->fg_color = DEFAULT_ANSI_FOREGROUND; 932 pcolor->bg_color = DEFAULT_ANSI_BACKGROUND; 933 #ifndef _HAVE_TEM_FIRMWARE 934 /* 935 * _HAVE_TEM_FIRMWARE is defined on SPARC, at this time, the 936 * plat_tem_get_colors() is implemented only on x86. 937 */ 938 plat_tem_get_colors(&pcolor->fg_color, &pcolor->bg_color); 939 #endif 940 941 tems_get_inverses(&inverse, &inverse_screen); 942 if (inverse) 943 flags |= TEM_ATTR_REVERSE; 944 if (inverse_screen) 945 flags |= TEM_ATTR_SCREEN_REVERSE; 946 947 if (flags != 0) { 948 /* 949 * If either reverse flag is set, the screen is in 950 * white-on-black mode. We set the bold flag to 951 * improve readability. 952 */ 953 flags |= TEM_ATTR_BOLD; 954 } else { 955 /* 956 * Otherwise, the screen is in black-on-white mode. 957 * The SPARC PROM console, which starts in this mode, 958 * uses the bright white background colour so we 959 * match it here. 960 */ 961 if (pcolor->bg_color == ANSI_COLOR_WHITE) 962 flags |= TEM_ATTR_BRIGHT_BG; 963 } 964 965 pcolor->a_flags = flags; 966 } 967 968 uchar_t 969 tem_get_fbmode(tem_vt_state_t tem_arg) 970 { 971 struct tem_vt_state *tem = (struct tem_vt_state *)tem_arg; 972 973 uchar_t fbmode; 974 975 mutex_enter(&tem->tvs_lock); 976 fbmode = tem->tvs_fbmode; 977 mutex_exit(&tem->tvs_lock); 978 979 return (fbmode); 980 } 981 982 void 983 tem_set_fbmode(tem_vt_state_t tem_arg, uchar_t fbmode, cred_t *credp) 984 { 985 struct tem_vt_state *tem = (struct tem_vt_state *)tem_arg; 986 987 mutex_enter(&tems.ts_lock); 988 mutex_enter(&tem->tvs_lock); 989 990 if (fbmode == tem->tvs_fbmode) { 991 mutex_exit(&tem->tvs_lock); 992 mutex_exit(&tems.ts_lock); 993 return; 994 } 995 996 tem->tvs_fbmode = fbmode; 997 998 if (tem->tvs_isactive) { 999 tem_kdsetmode(tem->tvs_fbmode, credp); 1000 if (fbmode == KD_TEXT) 1001 tem_safe_unblank_screen(tem, credp, CALLED_FROM_NORMAL); 1002 } 1003 1004 mutex_exit(&tem->tvs_lock); 1005 mutex_exit(&tems.ts_lock); 1006 } 1007 1008 void 1009 tem_activate(tem_vt_state_t tem_arg, boolean_t unblank, cred_t *credp) 1010 { 1011 struct tem_vt_state *tem = (struct tem_vt_state *)tem_arg; 1012 1013 mutex_enter(&tems.ts_lock); 1014 tems.ts_active = tem; 1015 1016 mutex_enter(&tem->tvs_lock); 1017 tem->tvs_isactive = B_TRUE; 1018 1019 tem_kdsetmode(tem->tvs_fbmode, credp); 1020 1021 if (unblank) 1022 tem_safe_unblank_screen(tem, credp, CALLED_FROM_NORMAL); 1023 1024 mutex_exit(&tem->tvs_lock); 1025 mutex_exit(&tems.ts_lock); 1026 } 1027 1028 void 1029 tem_switch(tem_vt_state_t tem_arg1, tem_vt_state_t tem_arg2, cred_t *credp) 1030 { 1031 struct tem_vt_state *cur = (struct tem_vt_state *)tem_arg1; 1032 struct tem_vt_state *tobe = (struct tem_vt_state *)tem_arg2; 1033 1034 mutex_enter(&tems.ts_lock); 1035 mutex_enter(&tobe->tvs_lock); 1036 mutex_enter(&cur->tvs_lock); 1037 1038 tems.ts_active = tobe; 1039 cur->tvs_isactive = B_FALSE; 1040 tobe->tvs_isactive = B_TRUE; 1041 1042 mutex_exit(&cur->tvs_lock); 1043 1044 if (cur->tvs_fbmode != tobe->tvs_fbmode) 1045 tem_kdsetmode(tobe->tvs_fbmode, credp); 1046 1047 if (tobe->tvs_fbmode == KD_TEXT) 1048 tem_safe_unblank_screen(tobe, credp, CALLED_FROM_NORMAL); 1049 1050 mutex_exit(&tobe->tvs_lock); 1051 mutex_exit(&tems.ts_lock); 1052 } 1053