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 * Copyright 2016 Joyent, Inc. 29 */ 30 31 /* 32 * Polled I/O safe ANSI terminal emulator module; 33 * Supporting TERM types 'sun' and 'sun-color, parsing 34 * ANSI x3.64 escape sequences, and the like. (See wscons(7d) 35 * for more information). 36 * 37 * IMPORTANT: 38 * 39 * The functions in this file *must* be able to function in 40 * standalone mode, ie. on a quiesced system. In that state, 41 * access is single threaded, only one CPU is running. 42 * System services are NOT available. 43 * 44 * The following restrictions pertain to every function 45 * in this file: 46 * 47 * - CANNOT use the DDI or LDI interfaces 48 * - CANNOT call system services 49 * - CANNOT use mutexes 50 * - CANNOT wait for interrupts 51 * - CANNOT allocate memory 52 * 53 * All non-static functions in this file which: 54 * - Operates on tems and tem_vt_state 55 * - Not only called from standalone mode, i.e. has 56 * a "calledfrom" argument 57 * should assert this at the beginning: 58 * 59 * ASSERT((MUTEX_HELD(&tems.ts_lock) && MUTEX_HELD(&tem->tvs_lock)) || 60 * called_from == CALLED_FROM_STANDALONE); 61 */ 62 63 #include <sys/types.h> 64 #include <sys/ascii.h> 65 #include <sys/visual_io.h> 66 #include <sys/font.h> 67 #include <sys/tem.h> 68 #include <sys/tem_impl.h> 69 #include <sys/ksynch.h> 70 #include <sys/sysmacros.h> 71 #include <sys/mutex.h> 72 #include <sys/note.h> 73 #include <sys/t_lock.h> 74 75 tem_safe_callbacks_t tem_safe_text_callbacks = { 76 &tem_safe_text_display, 77 &tem_safe_text_copy, 78 &tem_safe_text_cursor, 79 NULL, 80 &tem_safe_text_cls 81 }; 82 tem_safe_callbacks_t tem_safe_pix_callbacks = { 83 &tem_safe_pix_display, 84 &tem_safe_pix_copy, 85 &tem_safe_pix_cursor, 86 &tem_safe_pix_bit2pix, 87 &tem_safe_pix_cls 88 }; 89 90 91 static void tem_safe_control(struct tem_vt_state *, uchar_t, 92 cred_t *, enum called_from); 93 static void tem_safe_setparam(struct tem_vt_state *, int, int); 94 static void tem_safe_selgraph(struct tem_vt_state *); 95 static void tem_safe_chkparam(struct tem_vt_state *, uchar_t, 96 cred_t *, enum called_from); 97 static void tem_safe_getparams(struct tem_vt_state *, uchar_t, 98 cred_t *, enum called_from); 99 static void tem_safe_outch(struct tem_vt_state *, uchar_t, 100 cred_t *, enum called_from); 101 static void tem_safe_parse(struct tem_vt_state *, uchar_t, 102 cred_t *, enum called_from); 103 104 static void tem_safe_new_line(struct tem_vt_state *, 105 cred_t *, enum called_from); 106 static void tem_safe_cr(struct tem_vt_state *); 107 static void tem_safe_lf(struct tem_vt_state *, 108 cred_t *, enum called_from); 109 static void tem_safe_send_data(struct tem_vt_state *, cred_t *, 110 enum called_from); 111 static void tem_safe_cls(struct tem_vt_state *, 112 cred_t *, enum called_from); 113 static void tem_safe_tab(struct tem_vt_state *, 114 cred_t *, enum called_from); 115 static void tem_safe_back_tab(struct tem_vt_state *, 116 cred_t *, enum called_from); 117 static void tem_safe_clear_tabs(struct tem_vt_state *, int); 118 static void tem_safe_set_tab(struct tem_vt_state *); 119 static void tem_safe_mv_cursor(struct tem_vt_state *, int, int, 120 cred_t *, enum called_from); 121 static void tem_safe_shift(struct tem_vt_state *, int, int, 122 cred_t *, enum called_from); 123 static void tem_safe_scroll(struct tem_vt_state *, int, int, 124 int, int, cred_t *, enum called_from); 125 static void tem_safe_clear_chars(struct tem_vt_state *tem, 126 int count, screen_pos_t row, screen_pos_t col, 127 cred_t *credp, enum called_from called_from); 128 static void tem_safe_copy_area(struct tem_vt_state *tem, 129 screen_pos_t s_col, screen_pos_t s_row, 130 screen_pos_t e_col, screen_pos_t e_row, 131 screen_pos_t t_col, screen_pos_t t_row, 132 cred_t *credp, enum called_from called_from); 133 static void tem_safe_image_display(struct tem_vt_state *, uchar_t *, 134 int, int, screen_pos_t, screen_pos_t, 135 cred_t *, enum called_from); 136 static void tem_safe_bell(struct tem_vt_state *tem, 137 enum called_from called_from); 138 static void tem_safe_pix_clear_prom_output(struct tem_vt_state *tem, 139 cred_t *credp, enum called_from called_from); 140 141 static void tem_safe_virtual_cls(struct tem_vt_state *, int, screen_pos_t, 142 screen_pos_t); 143 static void tem_safe_virtual_display(struct tem_vt_state *, 144 unsigned char *, int, screen_pos_t, screen_pos_t, 145 text_color_t, text_color_t); 146 static void tem_safe_virtual_copy(struct tem_vt_state *, screen_pos_t, 147 screen_pos_t, screen_pos_t, screen_pos_t, 148 screen_pos_t, screen_pos_t); 149 static void tem_safe_align_cursor(struct tem_vt_state *tem); 150 static void bit_to_pix4(struct tem_vt_state *tem, uchar_t c, 151 text_color_t fg_color, text_color_t bg_color); 152 static void bit_to_pix8(struct tem_vt_state *tem, uchar_t c, 153 text_color_t fg_color, text_color_t bg_color); 154 static void bit_to_pix24(struct tem_vt_state *tem, uchar_t c, 155 text_color_t fg_color, text_color_t bg_color); 156 157 /* BEGIN CSTYLED */ 158 /* Bk Rd Gr Br Bl Mg Cy Wh */ 159 static text_color_t dim_xlate[] = { 1, 5, 3, 7, 2, 6, 4, 8 }; 160 static text_color_t brt_xlate[] = { 9, 13, 11, 15, 10, 14, 12, 0 }; 161 /* END CSTYLED */ 162 163 164 text_cmap_t cmap4_to_24 = { 165 /* BEGIN CSTYLED */ 166 /* 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 167 Wh+ Bk Bl Gr Cy Rd Mg Br Wh Bk+ Bl+ Gr+ Cy+ Rd+ Mg+ Yw */ 168 0xff,0x00,0x00,0x00,0x00,0x80,0x80,0x80,0x80,0x40,0x00,0x00,0x00,0xff,0xff,0xff, 169 0xff,0x00,0x00,0x80,0x80,0x00,0x00,0x80,0x80,0x40,0x00,0xff,0xff,0x00,0x00,0xff, 170 0xff,0x00,0x80,0x00,0x80,0x00,0x80,0x00,0x80,0x40,0xff,0x00,0xff,0x00,0xff,0x00 171 /* END CSTYLED */ 172 }; 173 174 #define PIX4TO32(pix4) (uint32_t)( \ 175 cmap4_to_24.red[pix4] << 16 | \ 176 cmap4_to_24.green[pix4] << 8 | \ 177 cmap4_to_24.blue[pix4]) 178 179 #define INVERSE(ch) (ch ^ 0xff) 180 181 #define tem_safe_callback_display (*tems.ts_callbacks->tsc_display) 182 #define tem_safe_callback_copy (*tems.ts_callbacks->tsc_copy) 183 #define tem_safe_callback_cursor (*tems.ts_callbacks->tsc_cursor) 184 #define tem_safe_callback_cls (*tems.ts_callbacks->tsc_cls) 185 #define tem_safe_callback_bit2pix(tem, c, fg, bg) { \ 186 ASSERT(tems.ts_callbacks->tsc_bit2pix != NULL); \ 187 (void) (*tems.ts_callbacks->tsc_bit2pix)((tem), (c), (fg), (bg));\ 188 } 189 190 void 191 tem_safe_check_first_time( 192 struct tem_vt_state *tem, 193 cred_t *credp, 194 enum called_from called_from) 195 { 196 static int first_time = 1; 197 198 ASSERT((MUTEX_HELD(&tems.ts_lock) && MUTEX_HELD(&tem->tvs_lock)) || 199 called_from == CALLED_FROM_STANDALONE); 200 201 /* 202 * Realign the console cursor. We did this in tem_init(). 203 * However, drivers in the console stream may emit additional 204 * messages before we are ready. This causes text overwrite 205 * on the screen. This is a workaround. 206 */ 207 if (!first_time) 208 return; 209 210 first_time = 0; 211 if (tems.ts_display_mode == VIS_TEXT) { 212 tem_safe_text_cursor(tem, VIS_GET_CURSOR, credp, called_from); 213 tem_safe_align_cursor(tem); 214 } 215 } 216 217 /* 218 * This entry point handles output requests from restricted contexts like 219 * kmdb, where services like mutexes are not available. This function 220 * is entered when OBP or when a kernel debugger (such as kmdb) 221 * are generating console output. In those cases, power management 222 * concerns are handled by the abort sequence initiation (ie. when 223 * the user hits L1+A or the equivalent to enter OBP or the debugger.). 224 * It is also entered when the kernel is panicing. 225 */ 226 void 227 tem_safe_polled_write( 228 tem_vt_state_t tem_arg, 229 uchar_t *buf, 230 int len) 231 { 232 struct tem_vt_state *tem = (struct tem_vt_state *)tem_arg; 233 234 #ifdef __lock_lint 235 _NOTE(NO_COMPETING_THREADS_NOW) 236 _NOTE(NO_COMPETING_THREADS_AS_SIDE_EFFECT) 237 #endif 238 239 if (!tem->tvs_initialized) { 240 return; 241 } 242 243 tem_safe_check_first_time(tem, kcred, CALLED_FROM_STANDALONE); 244 tem_safe_terminal_emulate(tem, buf, len, NULL, CALLED_FROM_STANDALONE); 245 } 246 247 /* Process partial UTF-8 sequence. */ 248 static void 249 tem_safe_input_partial(struct tem_vt_state *tem, cred_t *credp, 250 enum called_from called_from) 251 { 252 int i; 253 uint8_t c; 254 255 if (tem->tvs_utf8_left == 0) 256 return; 257 258 for (i = 0; i < sizeof (tem->tvs_utf8_partial); i++) { 259 c = (tem->tvs_utf8_partial >> (24 - (i << 3))) & 0xff; 260 if (c != 0) { 261 tem_safe_parse(tem, c, credp, called_from); 262 } 263 } 264 tem->tvs_utf8_left = 0; 265 tem->tvs_utf8_partial = 0; 266 } 267 268 /* 269 * Handle UTF-8 sequences. 270 */ 271 static void 272 tem_safe_input_byte(struct tem_vt_state *tem, uchar_t c, cred_t *credp, 273 enum called_from called_from) 274 { 275 /* 276 * Check for UTF-8 code points. In case of error fall back to 277 * 8-bit code. As we only have 8859-1 fonts for console, this will set 278 * the limits on what chars we actually can display, therefore we 279 * have to return to this code once we have solved the font issue. 280 */ 281 if ((c & 0x80) == 0x00) { 282 /* One-byte sequence. */ 283 tem_safe_input_partial(tem, credp, called_from); 284 tem_safe_parse(tem, c, credp, called_from); 285 return; 286 } 287 if ((c & 0xe0) == 0xc0) { 288 /* Two-byte sequence. */ 289 tem_safe_input_partial(tem, credp, called_from); 290 tem->tvs_utf8_left = 1; 291 tem->tvs_utf8_partial = c; 292 return; 293 } 294 if ((c & 0xf0) == 0xe0) { 295 /* Three-byte sequence. */ 296 tem_safe_input_partial(tem, credp, called_from); 297 tem->tvs_utf8_left = 2; 298 tem->tvs_utf8_partial = c; 299 return; 300 } 301 if ((c & 0xf8) == 0xf0) { 302 /* Four-byte sequence. */ 303 tem_safe_input_partial(tem, credp, called_from); 304 tem->tvs_utf8_left = 3; 305 tem->tvs_utf8_partial = c; 306 return; 307 } 308 if ((c & 0xc0) == 0x80) { 309 /* Invalid state? */ 310 if (tem->tvs_utf8_left == 0) { 311 tem_safe_parse(tem, c, credp, called_from); 312 return; 313 } 314 tem->tvs_utf8_left--; 315 tem->tvs_utf8_partial = (tem->tvs_utf8_partial << 8) | c; 316 if (tem->tvs_utf8_left == 0) { 317 tem_char_t v, u; 318 uint8_t b; 319 320 /* 321 * Transform the sequence of 2 to 4 bytes to 322 * unicode number. 323 */ 324 v = 0; 325 u = tem->tvs_utf8_partial; 326 b = (u >> 24) & 0xff; 327 if (b != 0) { /* Four-byte sequence */ 328 v = b & 0x07; 329 b = (u >> 16) & 0xff; 330 v = (v << 6) | (b & 0x3f); 331 b = (u >> 8) & 0xff; 332 v = (v << 6) | (b & 0x3f); 333 b = u & 0xff; 334 v = (v << 6) | (b & 0x3f); 335 } else if ((b = (u >> 16) & 0xff) != 0) { 336 v = b & 0x0f; /* Three-byte sequence */ 337 b = (u >> 8) & 0xff; 338 v = (v << 6) | (b & 0x3f); 339 b = u & 0xff; 340 v = (v << 6) | (b & 0x3f); 341 } else if ((b = (u >> 8) & 0xff) != 0) { 342 v = b & 0x1f; /* Two-byte sequence */ 343 b = u & 0xff; 344 v = (v << 6) | (b & 0x3f); 345 } 346 347 /* Use '?' as replacement if needed. */ 348 if (v > 0xff) 349 v = '?'; 350 tem_safe_parse(tem, v, credp, called_from); 351 tem->tvs_utf8_partial = 0; 352 } 353 return; 354 } 355 /* Anything left is illegal in UTF-8 sequence. */ 356 tem_safe_input_partial(tem, credp, called_from); 357 tem_safe_parse(tem, c, credp, called_from); 358 } 359 360 /* 361 * This is the main entry point into the terminal emulator. 362 * 363 * For each data message coming downstream, ANSI assumes that it is composed 364 * of ASCII characters, which are treated as a byte-stream input to the 365 * parsing state machine. All data is parsed immediately -- there is 366 * no enqueing. 367 */ 368 void 369 tem_safe_terminal_emulate( 370 struct tem_vt_state *tem, 371 uchar_t *buf, 372 int len, 373 cred_t *credp, 374 enum called_from called_from) 375 { 376 377 ASSERT((MUTEX_HELD(&tems.ts_lock) && MUTEX_HELD(&tem->tvs_lock)) || 378 called_from == CALLED_FROM_STANDALONE); 379 380 if (tem->tvs_isactive) 381 tem_safe_callback_cursor(tem, 382 VIS_HIDE_CURSOR, credp, called_from); 383 384 for (; len > 0; len--, buf++) 385 tem_safe_input_byte(tem, *buf, credp, called_from); 386 387 /* 388 * Send the data we just got to the framebuffer. 389 */ 390 tem_safe_send_data(tem, credp, called_from); 391 392 if (tem->tvs_isactive) 393 tem_safe_callback_cursor(tem, 394 VIS_DISPLAY_CURSOR, credp, called_from); 395 } 396 397 /* 398 * Display an rectangular image on the frame buffer using the 399 * mechanism appropriate for the system state being called 400 * from quiesced or normal (ie. use polled I/O vs. layered ioctls) 401 */ 402 static void 403 tems_safe_display(struct vis_consdisplay *pda, cred_t *credp, 404 enum called_from called_from) 405 { 406 if (called_from == CALLED_FROM_STANDALONE) 407 tems.ts_fb_polledio->display(tems.ts_fb_polledio->arg, pda); 408 else 409 tems_display_layered(pda, credp); 410 } 411 412 /* 413 * Copy a rectangle from one location to another on the frame buffer 414 * using the mechanism appropriate for the system state being called 415 * from, quiesced or normal (ie. use polled I/O vs. layered ioctls) 416 */ 417 void 418 tems_safe_copy(struct vis_conscopy *pca, cred_t *credp, 419 enum called_from called_from) 420 { 421 if (called_from == CALLED_FROM_STANDALONE) 422 tems.ts_fb_polledio->copy(tems.ts_fb_polledio->arg, pca); 423 else 424 tems_copy_layered(pca, credp); 425 } 426 427 /* 428 * Display or hide a rectangular block text cursor of a specificsize 429 * at a specific location on frame buffer* using the mechanism 430 * appropriate for the system state being called from, quisced or 431 * normal (ie. use polled I/O vs. layered ioctls). 432 */ 433 static void 434 tems_safe_cursor(struct vis_conscursor *pca, cred_t *credp, 435 enum called_from called_from) 436 { 437 if (called_from == CALLED_FROM_STANDALONE) 438 tems.ts_fb_polledio->cursor(tems.ts_fb_polledio->arg, pca); 439 else 440 tems_cursor_layered(pca, credp); 441 } 442 443 /* 444 * send the appropriate control message or set state based on the 445 * value of the control character ch 446 */ 447 448 static void 449 tem_safe_control(struct tem_vt_state *tem, uchar_t ch, cred_t *credp, 450 enum called_from called_from) 451 { 452 tem->tvs_state = A_STATE_START; 453 switch (ch) { 454 case A_BEL: 455 tem_safe_bell(tem, called_from); 456 break; 457 458 case A_BS: 459 tem_safe_mv_cursor(tem, 460 tem->tvs_c_cursor.row, 461 tem->tvs_c_cursor.col - 1, 462 credp, called_from); 463 break; 464 465 case A_HT: 466 tem_safe_tab(tem, credp, called_from); 467 break; 468 469 case A_NL: 470 /* 471 * tem_safe_send_data(tem, credp, called_from); 472 * tem_safe_new_line(tem, credp, called_from); 473 * break; 474 */ 475 476 case A_VT: 477 tem_safe_send_data(tem, credp, called_from); 478 tem_safe_lf(tem, credp, called_from); 479 break; 480 481 case A_FF: 482 tem_safe_send_data(tem, credp, called_from); 483 tem_safe_cls(tem, credp, called_from); 484 break; 485 486 case A_CR: 487 tem_safe_send_data(tem, credp, called_from); 488 tem_safe_cr(tem); 489 break; 490 491 case A_ESC: 492 tem->tvs_state = A_STATE_ESC; 493 break; 494 495 case A_CSI: 496 { 497 int i; 498 tem->tvs_curparam = 0; 499 tem->tvs_paramval = 0; 500 tem->tvs_gotparam = B_FALSE; 501 /* clear the parameters */ 502 for (i = 0; i < TEM_MAXPARAMS; i++) 503 tem->tvs_params[i] = -1; 504 tem->tvs_state = A_STATE_CSI; 505 } 506 break; 507 508 case A_GS: 509 tem_safe_back_tab(tem, credp, called_from); 510 break; 511 512 default: 513 break; 514 } 515 } 516 517 518 /* 519 * if parameters [0..count - 1] are not set, set them to the value 520 * of newparam. 521 */ 522 523 static void 524 tem_safe_setparam(struct tem_vt_state *tem, int count, int newparam) 525 { 526 int i; 527 528 for (i = 0; i < count; i++) { 529 if (tem->tvs_params[i] == -1) 530 tem->tvs_params[i] = newparam; 531 } 532 } 533 534 535 /* 536 * select graphics mode based on the param vals stored in a_params 537 */ 538 static void 539 tem_safe_selgraph(struct tem_vt_state *tem) 540 { 541 int curparam; 542 int count = 0; 543 int param; 544 545 tem->tvs_state = A_STATE_START; 546 547 curparam = tem->tvs_curparam; 548 do { 549 param = tem->tvs_params[count]; 550 551 switch (param) { 552 case -1: 553 case 0: 554 /* reset to initial normal settings */ 555 tem->tvs_fg_color = tems.ts_init_color.fg_color; 556 tem->tvs_bg_color = tems.ts_init_color.bg_color; 557 tem->tvs_flags = tems.ts_init_color.a_flags; 558 break; 559 560 case 1: /* Bold Intense */ 561 tem->tvs_flags |= TEM_ATTR_BOLD; 562 break; 563 564 case 2: /* Faint Intense */ 565 tem->tvs_flags &= ~TEM_ATTR_BOLD; 566 break; 567 568 case 5: /* Blink */ 569 tem->tvs_flags |= TEM_ATTR_BLINK; 570 break; 571 572 case 7: /* Reverse video */ 573 if (tem->tvs_flags & TEM_ATTR_SCREEN_REVERSE) { 574 tem->tvs_flags &= ~TEM_ATTR_REVERSE; 575 } else { 576 tem->tvs_flags |= TEM_ATTR_REVERSE; 577 } 578 break; 579 580 case 30: /* black (grey) foreground */ 581 case 31: /* red (light red) foreground */ 582 case 32: /* green (light green) foreground */ 583 case 33: /* brown (yellow) foreground */ 584 case 34: /* blue (light blue) foreground */ 585 case 35: /* magenta (light magenta) foreground */ 586 case 36: /* cyan (light cyan) foreground */ 587 case 37: /* white (bright white) foreground */ 588 tem->tvs_fg_color = param - 30; 589 tem->tvs_flags &= ~TEM_ATTR_BRIGHT_FG; 590 break; 591 592 case 39: 593 /* 594 * Reset the foreground colour and brightness. 595 */ 596 tem->tvs_fg_color = tems.ts_init_color.fg_color; 597 if (tems.ts_init_color.a_flags & TEM_ATTR_BRIGHT_FG) 598 tem->tvs_flags |= TEM_ATTR_BRIGHT_FG; 599 else 600 tem->tvs_flags &= ~TEM_ATTR_BRIGHT_FG; 601 break; 602 603 case 40: /* black (grey) background */ 604 case 41: /* red (light red) background */ 605 case 42: /* green (light green) background */ 606 case 43: /* brown (yellow) background */ 607 case 44: /* blue (light blue) background */ 608 case 45: /* magenta (light magenta) background */ 609 case 46: /* cyan (light cyan) background */ 610 case 47: /* white (bright white) background */ 611 tem->tvs_bg_color = param - 40; 612 tem->tvs_flags &= ~TEM_ATTR_BRIGHT_BG; 613 break; 614 615 case 49: 616 /* 617 * Reset the background colour and brightness. 618 */ 619 tem->tvs_bg_color = tems.ts_init_color.bg_color; 620 if (tems.ts_init_color.a_flags & TEM_ATTR_BRIGHT_BG) 621 tem->tvs_flags |= TEM_ATTR_BRIGHT_BG; 622 else 623 tem->tvs_flags &= ~TEM_ATTR_BRIGHT_BG; 624 break; 625 626 case 90: /* black (grey) foreground */ 627 case 91: /* red (light red) foreground */ 628 case 92: /* green (light green) foreground */ 629 case 93: /* brown (yellow) foreground */ 630 case 94: /* blue (light blue) foreground */ 631 case 95: /* magenta (light magenta) foreground */ 632 case 96: /* cyan (light cyan) foreground */ 633 case 97: /* white (bright white) foreground */ 634 tem->tvs_fg_color = param - 90; 635 tem->tvs_flags |= TEM_ATTR_BRIGHT_FG; 636 break; 637 638 case 100: /* black (grey) background */ 639 case 101: /* red (light red) background */ 640 case 102: /* green (light green) background */ 641 case 103: /* brown (yellow) background */ 642 case 104: /* blue (light blue) background */ 643 case 105: /* magenta (light magenta) background */ 644 case 106: /* cyan (light cyan) background */ 645 case 107: /* white (bright white) background */ 646 tem->tvs_bg_color = param - 100; 647 tem->tvs_flags |= TEM_ATTR_BRIGHT_BG; 648 break; 649 650 default: 651 break; 652 } 653 count++; 654 curparam--; 655 656 } while (curparam > 0); 657 } 658 659 /* 660 * perform the appropriate action for the escape sequence 661 * 662 * General rule: This code does not validate the arguments passed. 663 * It assumes that the next lower level will do so. 664 */ 665 static void 666 tem_safe_chkparam(struct tem_vt_state *tem, uchar_t ch, cred_t *credp, 667 enum called_from called_from) 668 { 669 int i; 670 int row; 671 int col; 672 673 ASSERT((called_from == CALLED_FROM_STANDALONE) || 674 MUTEX_HELD(&tem->tvs_lock)); 675 676 row = tem->tvs_c_cursor.row; 677 col = tem->tvs_c_cursor.col; 678 679 switch (ch) { 680 681 case 'm': /* select terminal graphics mode */ 682 tem_safe_send_data(tem, credp, called_from); 683 tem_safe_selgraph(tem); 684 break; 685 686 case '@': /* insert char */ 687 tem_safe_setparam(tem, 1, 1); 688 tem_safe_shift(tem, tem->tvs_params[0], TEM_SHIFT_RIGHT, 689 credp, called_from); 690 break; 691 692 case 'A': /* cursor up */ 693 tem_safe_setparam(tem, 1, 1); 694 tem_safe_mv_cursor(tem, row - tem->tvs_params[0], col, 695 credp, called_from); 696 break; 697 698 case 'd': /* VPA - vertical position absolute */ 699 tem_safe_setparam(tem, 1, 1); 700 tem_safe_mv_cursor(tem, tem->tvs_params[0] - 1, col, 701 credp, called_from); 702 break; 703 704 case 'e': /* VPR - vertical position relative */ 705 case 'B': /* cursor down */ 706 tem_safe_setparam(tem, 1, 1); 707 tem_safe_mv_cursor(tem, row + tem->tvs_params[0], col, 708 credp, called_from); 709 break; 710 711 case 'a': /* HPR - horizontal position relative */ 712 case 'C': /* cursor right */ 713 tem_safe_setparam(tem, 1, 1); 714 tem_safe_mv_cursor(tem, row, col + tem->tvs_params[0], 715 credp, called_from); 716 break; 717 718 case '`': /* HPA - horizontal position absolute */ 719 tem_safe_setparam(tem, 1, 1); 720 tem_safe_mv_cursor(tem, row, tem->tvs_params[0] - 1, 721 credp, called_from); 722 break; 723 724 case 'D': /* cursor left */ 725 tem_safe_setparam(tem, 1, 1); 726 tem_safe_mv_cursor(tem, row, col - tem->tvs_params[0], 727 credp, called_from); 728 break; 729 730 case 'E': /* CNL cursor next line */ 731 tem_safe_setparam(tem, 1, 1); 732 tem_safe_mv_cursor(tem, row + tem->tvs_params[0], 0, 733 credp, called_from); 734 break; 735 736 case 'F': /* CPL cursor previous line */ 737 tem_safe_setparam(tem, 1, 1); 738 tem_safe_mv_cursor(tem, row - tem->tvs_params[0], 0, 739 credp, called_from); 740 break; 741 742 case 'G': /* cursor horizontal position */ 743 tem_safe_setparam(tem, 1, 1); 744 tem_safe_mv_cursor(tem, row, tem->tvs_params[0] - 1, 745 credp, called_from); 746 break; 747 748 case 'g': /* clear tabs */ 749 tem_safe_setparam(tem, 1, 0); 750 tem_safe_clear_tabs(tem, tem->tvs_params[0]); 751 break; 752 753 case 'f': /* HVP Horizontal and Vertical Position */ 754 case 'H': /* CUP position cursor */ 755 tem_safe_setparam(tem, 2, 1); 756 tem_safe_mv_cursor(tem, 757 tem->tvs_params[0] - 1, 758 tem->tvs_params[1] - 1, 759 credp, called_from); 760 break; 761 762 case 'I': /* CHT - Cursor Horizontal Tab */ 763 /* Not implemented */ 764 break; 765 766 case 'J': /* ED - Erase in Display */ 767 tem_safe_send_data(tem, credp, called_from); 768 tem_safe_setparam(tem, 1, 0); 769 switch (tem->tvs_params[0]) { 770 case 0: 771 /* erase cursor to end of screen */ 772 /* FIRST erase cursor to end of line */ 773 tem_safe_clear_chars(tem, 774 tems.ts_c_dimension.width - 775 tem->tvs_c_cursor.col, 776 tem->tvs_c_cursor.row, 777 tem->tvs_c_cursor.col, credp, called_from); 778 779 /* THEN erase lines below the cursor */ 780 for (row = tem->tvs_c_cursor.row + 1; 781 row < tems.ts_c_dimension.height; 782 row++) { 783 tem_safe_clear_chars(tem, 784 tems.ts_c_dimension.width, 785 row, 0, credp, called_from); 786 } 787 break; 788 789 case 1: 790 /* erase beginning of screen to cursor */ 791 /* FIRST erase lines above the cursor */ 792 for (row = 0; 793 row < tem->tvs_c_cursor.row; 794 row++) { 795 tem_safe_clear_chars(tem, 796 tems.ts_c_dimension.width, 797 row, 0, credp, called_from); 798 } 799 /* THEN erase beginning of line to cursor */ 800 tem_safe_clear_chars(tem, 801 tem->tvs_c_cursor.col + 1, 802 tem->tvs_c_cursor.row, 803 0, credp, called_from); 804 break; 805 806 case 2: 807 /* erase whole screen */ 808 for (row = 0; 809 row < tems.ts_c_dimension.height; 810 row++) { 811 tem_safe_clear_chars(tem, 812 tems.ts_c_dimension.width, 813 row, 0, credp, called_from); 814 } 815 break; 816 } 817 break; 818 819 case 'K': /* EL - Erase in Line */ 820 tem_safe_send_data(tem, credp, called_from); 821 tem_safe_setparam(tem, 1, 0); 822 switch (tem->tvs_params[0]) { 823 case 0: 824 /* erase cursor to end of line */ 825 tem_safe_clear_chars(tem, 826 (tems.ts_c_dimension.width - 827 tem->tvs_c_cursor.col), 828 tem->tvs_c_cursor.row, 829 tem->tvs_c_cursor.col, 830 credp, called_from); 831 break; 832 833 case 1: 834 /* erase beginning of line to cursor */ 835 tem_safe_clear_chars(tem, 836 tem->tvs_c_cursor.col + 1, 837 tem->tvs_c_cursor.row, 838 0, credp, called_from); 839 break; 840 841 case 2: 842 /* erase whole line */ 843 tem_safe_clear_chars(tem, 844 tems.ts_c_dimension.width, 845 tem->tvs_c_cursor.row, 846 0, credp, called_from); 847 break; 848 } 849 break; 850 851 case 'L': /* insert line */ 852 tem_safe_send_data(tem, credp, called_from); 853 tem_safe_setparam(tem, 1, 1); 854 tem_safe_scroll(tem, 855 tem->tvs_c_cursor.row, 856 tems.ts_c_dimension.height - 1, 857 tem->tvs_params[0], TEM_SCROLL_DOWN, 858 credp, called_from); 859 break; 860 861 case 'M': /* delete line */ 862 tem_safe_send_data(tem, credp, called_from); 863 tem_safe_setparam(tem, 1, 1); 864 tem_safe_scroll(tem, 865 tem->tvs_c_cursor.row, 866 tems.ts_c_dimension.height - 1, 867 tem->tvs_params[0], TEM_SCROLL_UP, 868 credp, called_from); 869 break; 870 871 case 'P': /* DCH - delete char */ 872 tem_safe_setparam(tem, 1, 1); 873 tem_safe_shift(tem, tem->tvs_params[0], TEM_SHIFT_LEFT, 874 credp, called_from); 875 break; 876 877 case 'S': /* scroll up */ 878 tem_safe_send_data(tem, credp, called_from); 879 tem_safe_setparam(tem, 1, 1); 880 tem_safe_scroll(tem, 0, 881 tems.ts_c_dimension.height - 1, 882 tem->tvs_params[0], TEM_SCROLL_UP, 883 credp, called_from); 884 break; 885 886 case 'T': /* scroll down */ 887 tem_safe_send_data(tem, credp, called_from); 888 tem_safe_setparam(tem, 1, 1); 889 tem_safe_scroll(tem, 0, 890 tems.ts_c_dimension.height - 1, 891 tem->tvs_params[0], TEM_SCROLL_DOWN, 892 credp, called_from); 893 break; 894 895 case 'X': /* erase char */ 896 tem_safe_setparam(tem, 1, 1); 897 tem_safe_clear_chars(tem, 898 tem->tvs_params[0], 899 tem->tvs_c_cursor.row, 900 tem->tvs_c_cursor.col, 901 credp, called_from); 902 break; 903 904 case 'Z': /* cursor backward tabulation */ 905 tem_safe_setparam(tem, 1, 1); 906 907 /* 908 * Rule exception - We do sanity checking here. 909 * 910 * Restrict the count to a sane value to keep from 911 * looping for a long time. There can't be more than one 912 * tab stop per column, so use that as a limit. 913 */ 914 if (tem->tvs_params[0] > tems.ts_c_dimension.width) 915 tem->tvs_params[0] = tems.ts_c_dimension.width; 916 917 for (i = 0; i < tem->tvs_params[0]; i++) 918 tem_safe_back_tab(tem, credp, called_from); 919 break; 920 } 921 tem->tvs_state = A_STATE_START; 922 } 923 924 925 /* 926 * Gather the parameters of an ANSI escape sequence 927 */ 928 static void 929 tem_safe_getparams(struct tem_vt_state *tem, uchar_t ch, 930 cred_t *credp, enum called_from called_from) 931 { 932 ASSERT((called_from == CALLED_FROM_STANDALONE) || 933 MUTEX_HELD(&tem->tvs_lock)); 934 935 if (ch >= '0' && ch <= '9') { 936 tem->tvs_paramval = ((tem->tvs_paramval * 10) + (ch - '0')); 937 tem->tvs_gotparam = B_TRUE; /* Remember got parameter */ 938 return; /* Return immediately */ 939 } else if (tem->tvs_state == A_STATE_CSI_EQUAL || 940 tem->tvs_state == A_STATE_CSI_QMARK) { 941 tem->tvs_state = A_STATE_START; 942 } else { 943 if (tem->tvs_curparam < TEM_MAXPARAMS) { 944 if (tem->tvs_gotparam) { 945 /* get the parameter value */ 946 tem->tvs_params[tem->tvs_curparam] = 947 tem->tvs_paramval; 948 } 949 tem->tvs_curparam++; 950 } 951 952 if (ch == ';') { 953 /* Restart parameter search */ 954 tem->tvs_gotparam = B_FALSE; 955 tem->tvs_paramval = 0; /* No parame value yet */ 956 } else { 957 /* Handle escape sequence */ 958 tem_safe_chkparam(tem, ch, credp, called_from); 959 } 960 } 961 } 962 963 /* 964 * Add character to internal buffer. 965 * When its full, send it to the next layer. 966 */ 967 968 static void 969 tem_safe_outch(struct tem_vt_state *tem, uchar_t ch, 970 cred_t *credp, enum called_from called_from) 971 { 972 973 ASSERT((MUTEX_HELD(&tems.ts_lock) && MUTEX_HELD(&tem->tvs_lock)) || 974 called_from == CALLED_FROM_STANDALONE); 975 976 /* buffer up the character until later */ 977 978 tem->tvs_outbuf[tem->tvs_outindex++] = ch; 979 tem->tvs_c_cursor.col++; 980 if (tem->tvs_c_cursor.col >= tems.ts_c_dimension.width) { 981 tem_safe_send_data(tem, credp, called_from); 982 tem_safe_new_line(tem, credp, called_from); 983 } 984 } 985 986 static void 987 tem_safe_new_line(struct tem_vt_state *tem, 988 cred_t *credp, enum called_from called_from) 989 { 990 tem_safe_cr(tem); 991 tem_safe_lf(tem, credp, called_from); 992 } 993 994 static void 995 tem_safe_cr(struct tem_vt_state *tem) 996 { 997 tem->tvs_c_cursor.col = 0; 998 tem_safe_align_cursor(tem); 999 } 1000 1001 static void 1002 tem_safe_lf(struct tem_vt_state *tem, 1003 cred_t *credp, enum called_from called_from) 1004 { 1005 int row; 1006 1007 ASSERT((called_from == CALLED_FROM_STANDALONE) || 1008 MUTEX_HELD(&tem->tvs_lock)); 1009 1010 /* 1011 * Sanity checking notes: 1012 * . a_nscroll was validated when it was set. 1013 * . Regardless of that, tem_safe_scroll and tem_safe_mv_cursor 1014 * will prevent anything bad from happening. 1015 */ 1016 row = tem->tvs_c_cursor.row + 1; 1017 1018 if (row >= tems.ts_c_dimension.height) { 1019 if (tem->tvs_nscroll != 0) { 1020 tem_safe_scroll(tem, 0, 1021 tems.ts_c_dimension.height - 1, 1022 tem->tvs_nscroll, TEM_SCROLL_UP, 1023 credp, called_from); 1024 row = tems.ts_c_dimension.height - 1025 tem->tvs_nscroll; 1026 } else { /* no scroll */ 1027 /* 1028 * implement Esc[#r when # is zero. This means no 1029 * scroll but just return cursor to top of screen, 1030 * do not clear screen. 1031 */ 1032 row = 0; 1033 } 1034 } 1035 1036 tem_safe_mv_cursor(tem, row, tem->tvs_c_cursor.col, 1037 credp, called_from); 1038 1039 if (tem->tvs_nscroll == 0) { 1040 /* erase rest of cursor line */ 1041 tem_safe_clear_chars(tem, 1042 tems.ts_c_dimension.width - 1043 tem->tvs_c_cursor.col, 1044 tem->tvs_c_cursor.row, 1045 tem->tvs_c_cursor.col, 1046 credp, called_from); 1047 1048 } 1049 1050 tem_safe_align_cursor(tem); 1051 } 1052 1053 static void 1054 tem_safe_send_data(struct tem_vt_state *tem, cred_t *credp, 1055 enum called_from called_from) 1056 { 1057 text_color_t fg_color; 1058 text_color_t bg_color; 1059 1060 ASSERT((called_from == CALLED_FROM_STANDALONE) || 1061 MUTEX_HELD(&tem->tvs_lock)); 1062 1063 if (tem->tvs_outindex == 0) { 1064 tem_safe_align_cursor(tem); 1065 return; 1066 } 1067 1068 tem_safe_get_color(tem, &fg_color, &bg_color, TEM_ATTR_REVERSE); 1069 tem_safe_virtual_display(tem, 1070 tem->tvs_outbuf, tem->tvs_outindex, 1071 tem->tvs_s_cursor.row, tem->tvs_s_cursor.col, 1072 fg_color, bg_color); 1073 1074 if (tem->tvs_isactive) { 1075 /* 1076 * Call the primitive to render this data. 1077 */ 1078 tem_safe_callback_display(tem, 1079 tem->tvs_outbuf, tem->tvs_outindex, 1080 tem->tvs_s_cursor.row, tem->tvs_s_cursor.col, 1081 fg_color, bg_color, 1082 credp, called_from); 1083 } 1084 1085 tem->tvs_outindex = 0; 1086 1087 tem_safe_align_cursor(tem); 1088 } 1089 1090 1091 /* 1092 * We have just done something to the current output point. Reset the start 1093 * point for the buffered data in a_outbuf. There shouldn't be any data 1094 * buffered yet. 1095 */ 1096 static void 1097 tem_safe_align_cursor(struct tem_vt_state *tem) 1098 { 1099 tem->tvs_s_cursor.row = tem->tvs_c_cursor.row; 1100 tem->tvs_s_cursor.col = tem->tvs_c_cursor.col; 1101 } 1102 1103 /* 1104 * State machine parser based on the current state and character input 1105 * major terminations are to control character or normal character 1106 */ 1107 1108 static void 1109 tem_safe_parse(struct tem_vt_state *tem, uchar_t ch, 1110 cred_t *credp, enum called_from called_from) 1111 { 1112 int i; 1113 1114 ASSERT((called_from == CALLED_FROM_STANDALONE) || 1115 MUTEX_HELD(&tem->tvs_lock)); 1116 1117 if (tem->tvs_state == A_STATE_START) { /* Normal state? */ 1118 if (ch == A_CSI || ch == A_ESC || ch < ' ') { 1119 /* Control */ 1120 tem_safe_control(tem, ch, credp, called_from); 1121 } else { 1122 /* Display */ 1123 tem_safe_outch(tem, ch, credp, called_from); 1124 } 1125 return; 1126 } 1127 1128 /* In <ESC> sequence */ 1129 if (tem->tvs_state != A_STATE_ESC) { /* Need to get parameters? */ 1130 if (tem->tvs_state != A_STATE_CSI) { 1131 tem_safe_getparams(tem, ch, credp, called_from); 1132 return; 1133 } 1134 1135 switch (ch) { 1136 case '?': 1137 tem->tvs_state = A_STATE_CSI_QMARK; 1138 return; 1139 case '=': 1140 tem->tvs_state = A_STATE_CSI_EQUAL; 1141 return; 1142 case 's': 1143 /* 1144 * As defined below, this sequence 1145 * saves the cursor. However, Sun 1146 * defines ESC[s as reset. We resolved 1147 * the conflict by selecting reset as it 1148 * is exported in the termcap file for 1149 * sun-mon, while the "save cursor" 1150 * definition does not exist anywhere in 1151 * /etc/termcap. 1152 * However, having no coherent 1153 * definition of reset, we have not 1154 * implemented it. 1155 */ 1156 1157 /* 1158 * Original code 1159 * tem->tvs_r_cursor.row = tem->tvs_c_cursor.row; 1160 * tem->tvs_r_cursor.col = tem->tvs_c_cursor.col; 1161 * tem->tvs_state = A_STATE_START; 1162 */ 1163 1164 tem->tvs_state = A_STATE_START; 1165 return; 1166 case 'u': 1167 tem_safe_mv_cursor(tem, tem->tvs_r_cursor.row, 1168 tem->tvs_r_cursor.col, credp, called_from); 1169 tem->tvs_state = A_STATE_START; 1170 return; 1171 case 'p': /* sunbow */ 1172 tem_safe_send_data(tem, credp, called_from); 1173 /* 1174 * Don't set anything if we are 1175 * already as we want to be. 1176 */ 1177 if (tem->tvs_flags & TEM_ATTR_SCREEN_REVERSE) { 1178 tem->tvs_flags &= ~TEM_ATTR_SCREEN_REVERSE; 1179 /* 1180 * If we have switched the characters to be the 1181 * inverse from the screen, then switch them as 1182 * well to keep them the inverse of the screen. 1183 */ 1184 if (tem->tvs_flags & TEM_ATTR_REVERSE) 1185 tem->tvs_flags &= ~TEM_ATTR_REVERSE; 1186 else 1187 tem->tvs_flags |= TEM_ATTR_REVERSE; 1188 } 1189 tem_safe_cls(tem, credp, called_from); 1190 tem->tvs_state = A_STATE_START; 1191 return; 1192 case 'q': /* sunwob */ 1193 tem_safe_send_data(tem, credp, called_from); 1194 /* 1195 * Don't set anything if we are 1196 * already where as we want to be. 1197 */ 1198 if (!(tem->tvs_flags & TEM_ATTR_SCREEN_REVERSE)) { 1199 tem->tvs_flags |= TEM_ATTR_SCREEN_REVERSE; 1200 /* 1201 * If we have switched the characters to be the 1202 * inverse from the screen, then switch them as 1203 * well to keep them the inverse of the screen. 1204 */ 1205 if (!(tem->tvs_flags & TEM_ATTR_REVERSE)) 1206 tem->tvs_flags |= TEM_ATTR_REVERSE; 1207 else 1208 tem->tvs_flags &= ~TEM_ATTR_REVERSE; 1209 } 1210 1211 tem_safe_cls(tem, credp, called_from); 1212 tem->tvs_state = A_STATE_START; 1213 return; 1214 case 'r': /* sunscrl */ 1215 /* 1216 * Rule exception: check for validity here. 1217 */ 1218 tem->tvs_nscroll = tem->tvs_paramval; 1219 if (tem->tvs_nscroll > tems.ts_c_dimension.height) 1220 tem->tvs_nscroll = tems.ts_c_dimension.height; 1221 if (tem->tvs_nscroll < 0) 1222 tem->tvs_nscroll = 1; 1223 tem->tvs_state = A_STATE_START; 1224 return; 1225 default: 1226 tem_safe_getparams(tem, ch, credp, called_from); 1227 return; 1228 } 1229 } 1230 1231 /* Previous char was <ESC> */ 1232 if (ch == '[') { 1233 tem->tvs_curparam = 0; 1234 tem->tvs_paramval = 0; 1235 tem->tvs_gotparam = B_FALSE; 1236 /* clear the parameters */ 1237 for (i = 0; i < TEM_MAXPARAMS; i++) 1238 tem->tvs_params[i] = -1; 1239 tem->tvs_state = A_STATE_CSI; 1240 } else if (ch == 'Q') { /* <ESC>Q ? */ 1241 tem->tvs_state = A_STATE_START; 1242 } else if (ch == 'C') { /* <ESC>C ? */ 1243 tem->tvs_state = A_STATE_START; 1244 } else { 1245 tem->tvs_state = A_STATE_START; 1246 if (ch == 'c') { 1247 /* ESC c resets display */ 1248 tem_safe_reset_display(tem, credp, called_from, 1249 B_TRUE, B_TRUE); 1250 } else if (ch == 'H') { 1251 /* ESC H sets a tab */ 1252 tem_safe_set_tab(tem); 1253 } else if (ch == '7') { 1254 /* ESC 7 Save Cursor position */ 1255 tem->tvs_r_cursor.row = tem->tvs_c_cursor.row; 1256 tem->tvs_r_cursor.col = tem->tvs_c_cursor.col; 1257 } else if (ch == '8') { 1258 /* ESC 8 Restore Cursor position */ 1259 tem_safe_mv_cursor(tem, tem->tvs_r_cursor.row, 1260 tem->tvs_r_cursor.col, credp, called_from); 1261 /* check for control chars */ 1262 } else if (ch < ' ') { 1263 tem_safe_control(tem, ch, credp, called_from); 1264 } else { 1265 tem_safe_outch(tem, ch, credp, called_from); 1266 } 1267 } 1268 } 1269 1270 /* ARGSUSED */ 1271 static void 1272 tem_safe_bell(struct tem_vt_state *tem, enum called_from called_from) 1273 { 1274 if (called_from == CALLED_FROM_STANDALONE) 1275 (void) beep_polled(BEEP_CONSOLE); 1276 else 1277 (void) beep(BEEP_CONSOLE); 1278 } 1279 1280 1281 static void 1282 tem_safe_scroll(struct tem_vt_state *tem, int start, int end, int count, 1283 int direction, cred_t *credp, enum called_from called_from) 1284 { 1285 int row; 1286 int lines_affected; 1287 1288 ASSERT((MUTEX_HELD(&tems.ts_lock) && MUTEX_HELD(&tem->tvs_lock)) || 1289 called_from == CALLED_FROM_STANDALONE); 1290 1291 lines_affected = end - start + 1; 1292 if (count > lines_affected) 1293 count = lines_affected; 1294 if (count <= 0) 1295 return; 1296 1297 switch (direction) { 1298 case TEM_SCROLL_UP: 1299 if (count < lines_affected) { 1300 tem_safe_copy_area(tem, 0, start + count, 1301 tems.ts_c_dimension.width - 1, end, 1302 0, start, credp, called_from); 1303 } 1304 for (row = (end - count) + 1; row <= end; row++) { 1305 tem_safe_clear_chars(tem, tems.ts_c_dimension.width, 1306 row, 0, credp, called_from); 1307 } 1308 break; 1309 1310 case TEM_SCROLL_DOWN: 1311 if (count < lines_affected) { 1312 tem_safe_copy_area(tem, 0, start, 1313 tems.ts_c_dimension.width - 1, 1314 end - count, 0, start + count, 1315 credp, called_from); 1316 } 1317 for (row = start; row < start + count; row++) { 1318 tem_safe_clear_chars(tem, tems.ts_c_dimension.width, 1319 row, 0, credp, called_from); 1320 } 1321 break; 1322 } 1323 } 1324 1325 static void 1326 tem_safe_copy_area(struct tem_vt_state *tem, 1327 screen_pos_t s_col, screen_pos_t s_row, 1328 screen_pos_t e_col, screen_pos_t e_row, 1329 screen_pos_t t_col, screen_pos_t t_row, 1330 cred_t *credp, enum called_from called_from) 1331 { 1332 int rows; 1333 int cols; 1334 1335 ASSERT((MUTEX_HELD(&tems.ts_lock) && MUTEX_HELD(&tem->tvs_lock)) || 1336 called_from == CALLED_FROM_STANDALONE); 1337 1338 if (s_col < 0 || s_row < 0 || 1339 e_col < 0 || e_row < 0 || 1340 t_col < 0 || t_row < 0 || 1341 s_col >= tems.ts_c_dimension.width || 1342 e_col >= tems.ts_c_dimension.width || 1343 t_col >= tems.ts_c_dimension.width || 1344 s_row >= tems.ts_c_dimension.height || 1345 e_row >= tems.ts_c_dimension.height || 1346 t_row >= tems.ts_c_dimension.height) 1347 return; 1348 1349 if (s_row > e_row || s_col > e_col) 1350 return; 1351 1352 rows = e_row - s_row + 1; 1353 cols = e_col - s_col + 1; 1354 if (t_row + rows > tems.ts_c_dimension.height || 1355 t_col + cols > tems.ts_c_dimension.width) 1356 return; 1357 1358 tem_safe_virtual_copy(tem, 1359 s_col, s_row, 1360 e_col, e_row, 1361 t_col, t_row); 1362 1363 if (!tem->tvs_isactive) 1364 return; 1365 1366 tem_safe_callback_copy(tem, s_col, s_row, 1367 e_col, e_row, t_col, t_row, credp, called_from); 1368 } 1369 1370 static void 1371 tem_safe_clear_chars(struct tem_vt_state *tem, int count, screen_pos_t row, 1372 screen_pos_t col, cred_t *credp, enum called_from called_from) 1373 { 1374 ASSERT((MUTEX_HELD(&tems.ts_lock) && MUTEX_HELD(&tem->tvs_lock)) || 1375 called_from == CALLED_FROM_STANDALONE); 1376 1377 if (row < 0 || row >= tems.ts_c_dimension.height || 1378 col < 0 || col >= tems.ts_c_dimension.width || 1379 count < 0) 1380 return; 1381 1382 /* 1383 * Note that very large values of "count" could cause col+count 1384 * to overflow, so we check "count" independently. 1385 */ 1386 if (count > tems.ts_c_dimension.width || 1387 col + count > tems.ts_c_dimension.width) 1388 count = tems.ts_c_dimension.width - col; 1389 1390 tem_safe_virtual_cls(tem, count, row, col); 1391 1392 if (!tem->tvs_isactive) 1393 return; 1394 1395 tem_safe_callback_cls(tem, count, row, col, credp, called_from); 1396 } 1397 1398 /*ARGSUSED*/ 1399 void 1400 tem_safe_text_display(struct tem_vt_state *tem, uchar_t *string, 1401 int count, screen_pos_t row, screen_pos_t col, 1402 text_color_t fg_color, text_color_t bg_color, 1403 cred_t *credp, enum called_from called_from) 1404 { 1405 struct vis_consdisplay da; 1406 1407 ASSERT((MUTEX_HELD(&tems.ts_lock) && MUTEX_HELD(&tem->tvs_lock)) || 1408 called_from == CALLED_FROM_STANDALONE); 1409 1410 da.data = string; 1411 da.width = (screen_size_t)count; 1412 da.row = row; 1413 da.col = col; 1414 1415 da.fg_color = fg_color; 1416 da.bg_color = bg_color; 1417 1418 tems_safe_display(&da, credp, called_from); 1419 } 1420 1421 /* 1422 * This function is used to blit a rectangular color image, 1423 * unperturbed on the underlying framebuffer, to render 1424 * icons and pictures. The data is a pixel pattern that 1425 * fills a rectangle bounded to the width and height parameters. 1426 * The color pixel data must to be pre-adjusted by the caller 1427 * for the current video depth. 1428 * 1429 * This function is unused now. 1430 */ 1431 /*ARGSUSED*/ 1432 static void 1433 tem_safe_image_display(struct tem_vt_state *tem, uchar_t *image, 1434 int height, int width, screen_pos_t row, screen_pos_t col, 1435 cred_t *credp, enum called_from called_from) 1436 { 1437 struct vis_consdisplay da; 1438 1439 mutex_enter(&tems.ts_lock); 1440 mutex_enter(&tem->tvs_lock); 1441 1442 da.data = image; 1443 da.width = (screen_size_t)width; 1444 da.height = (screen_size_t)height; 1445 da.row = row; 1446 da.col = col; 1447 1448 tems_safe_display(&da, credp, called_from); 1449 1450 mutex_exit(&tem->tvs_lock); 1451 mutex_exit(&tems.ts_lock); 1452 } 1453 1454 1455 /*ARGSUSED*/ 1456 void 1457 tem_safe_text_copy(struct tem_vt_state *tem, 1458 screen_pos_t s_col, screen_pos_t s_row, 1459 screen_pos_t e_col, screen_pos_t e_row, 1460 screen_pos_t t_col, screen_pos_t t_row, 1461 cred_t *credp, enum called_from called_from) 1462 { 1463 struct vis_conscopy da; 1464 1465 ASSERT((MUTEX_HELD(&tems.ts_lock) && MUTEX_HELD(&tem->tvs_lock)) || 1466 called_from == CALLED_FROM_STANDALONE); 1467 1468 da.s_row = s_row; 1469 da.s_col = s_col; 1470 da.e_row = e_row; 1471 da.e_col = e_col; 1472 da.t_row = t_row; 1473 da.t_col = t_col; 1474 1475 tems_safe_copy(&da, credp, called_from); 1476 } 1477 1478 void 1479 tem_safe_text_cls(struct tem_vt_state *tem, 1480 int count, screen_pos_t row, screen_pos_t col, cred_t *credp, 1481 enum called_from called_from) 1482 { 1483 struct vis_consdisplay da; 1484 1485 ASSERT((MUTEX_HELD(&tems.ts_lock) && MUTEX_HELD(&tem->tvs_lock)) || 1486 called_from == CALLED_FROM_STANDALONE); 1487 1488 da.data = tems.ts_blank_line; 1489 da.width = (screen_size_t)count; 1490 da.row = row; 1491 da.col = col; 1492 1493 tem_safe_get_color(tem, &da.fg_color, &da.bg_color, 1494 TEM_ATTR_SCREEN_REVERSE); 1495 tems_safe_display(&da, credp, called_from); 1496 } 1497 1498 void 1499 tem_safe_pix_display(struct tem_vt_state *tem, 1500 uchar_t *string, int count, 1501 screen_pos_t row, screen_pos_t col, 1502 text_color_t fg_color, text_color_t bg_color, 1503 cred_t *credp, enum called_from called_from) 1504 { 1505 struct vis_consdisplay da; 1506 int i; 1507 1508 ASSERT((MUTEX_HELD(&tems.ts_lock) && MUTEX_HELD(&tem->tvs_lock)) || 1509 called_from == CALLED_FROM_STANDALONE); 1510 1511 da.data = (uchar_t *)tem->tvs_pix_data; 1512 da.width = tems.ts_font.width; 1513 da.height = tems.ts_font.height; 1514 da.row = (row * da.height) + tems.ts_p_offset.y; 1515 da.col = (col * da.width) + tems.ts_p_offset.x; 1516 1517 for (i = 0; i < count; i++) { 1518 tem_safe_callback_bit2pix(tem, string[i], fg_color, bg_color); 1519 tems_safe_display(&da, credp, called_from); 1520 da.col += da.width; 1521 } 1522 } 1523 1524 void 1525 tem_safe_pix_copy(struct tem_vt_state *tem, 1526 screen_pos_t s_col, screen_pos_t s_row, 1527 screen_pos_t e_col, screen_pos_t e_row, 1528 screen_pos_t t_col, screen_pos_t t_row, 1529 cred_t *credp, 1530 enum called_from called_from) 1531 { 1532 struct vis_conscopy ma; 1533 static boolean_t need_clear = B_TRUE; 1534 1535 ASSERT((MUTEX_HELD(&tems.ts_lock) && MUTEX_HELD(&tem->tvs_lock)) || 1536 called_from == CALLED_FROM_STANDALONE); 1537 1538 if (need_clear && tem->tvs_first_line > 0) { 1539 /* 1540 * Clear OBP output above our kernel console term 1541 * when our kernel console term begins to scroll up, 1542 * we hope it is user friendly. 1543 * (Also see comments on tem_safe_pix_clear_prom_output) 1544 * 1545 * This is only one time call. 1546 */ 1547 tem_safe_pix_clear_prom_output(tem, credp, called_from); 1548 } 1549 need_clear = B_FALSE; 1550 1551 ma.s_row = s_row * tems.ts_font.height + tems.ts_p_offset.y; 1552 ma.e_row = (e_row + 1) * tems.ts_font.height + tems.ts_p_offset.y - 1; 1553 ma.t_row = t_row * tems.ts_font.height + tems.ts_p_offset.y; 1554 1555 /* 1556 * Check if we're in process of clearing OBP's columns area, 1557 * which only happens when term scrolls up a whole line. 1558 */ 1559 if (tem->tvs_first_line > 0 && t_row < s_row && t_col == 0 && 1560 e_col == tems.ts_c_dimension.width - 1) { 1561 /* 1562 * We need to clear OBP's columns area outside our kernel 1563 * console term. So that we set ma.e_col to entire row here. 1564 */ 1565 ma.s_col = s_col * tems.ts_font.width; 1566 ma.e_col = tems.ts_p_dimension.width - 1; 1567 1568 ma.t_col = t_col * tems.ts_font.width; 1569 } else { 1570 ma.s_col = s_col * tems.ts_font.width + tems.ts_p_offset.x; 1571 ma.e_col = (e_col + 1) * tems.ts_font.width + 1572 tems.ts_p_offset.x - 1; 1573 ma.t_col = t_col * tems.ts_font.width + tems.ts_p_offset.x; 1574 } 1575 1576 tems_safe_copy(&ma, credp, called_from); 1577 1578 if (tem->tvs_first_line > 0 && t_row < s_row) { 1579 /* We have scrolled up (s_row - t_row) rows. */ 1580 tem->tvs_first_line -= (s_row - t_row); 1581 if (tem->tvs_first_line <= 0) { 1582 /* All OBP rows have been cleared. */ 1583 tem->tvs_first_line = 0; 1584 } 1585 } 1586 1587 } 1588 1589 void 1590 tem_safe_pix_bit2pix(struct tem_vt_state *tem, unsigned char c, 1591 unsigned char fg, unsigned char bg) 1592 { 1593 void (*fp)(struct tem_vt_state *, unsigned char, 1594 unsigned char, unsigned char); 1595 1596 switch (tems.ts_pdepth) { 1597 case 4: 1598 fp = bit_to_pix4; 1599 break; 1600 case 8: 1601 fp = bit_to_pix8; 1602 break; 1603 case 24: 1604 case 32: 1605 fp = bit_to_pix24; 1606 } 1607 1608 fp(tem, c, fg, bg); 1609 } 1610 1611 1612 /* 1613 * This function only clears count of columns in one row 1614 */ 1615 void 1616 tem_safe_pix_cls(struct tem_vt_state *tem, int count, 1617 screen_pos_t row, screen_pos_t col, cred_t *credp, 1618 enum called_from called_from) 1619 { 1620 ASSERT((MUTEX_HELD(&tems.ts_lock) && MUTEX_HELD(&tem->tvs_lock)) || 1621 called_from == CALLED_FROM_STANDALONE); 1622 1623 tem_safe_pix_cls_range(tem, row, 1, tems.ts_p_offset.y, 1624 col, count, tems.ts_p_offset.x, B_FALSE, credp, called_from); 1625 } 1626 1627 /* 1628 * This function clears OBP output above our kernel console term area 1629 * because OBP's term may have a bigger terminal window than that of 1630 * our kernel console term. So we need to clear OBP output garbage outside 1631 * of our kernel console term at a proper time, which is when the first 1632 * row output of our kernel console term scrolls at the first screen line. 1633 * 1634 * _________________________________ 1635 * | _____________________ | ---> OBP's bigger term window 1636 * | | | | 1637 * |___| | | 1638 * | | | | | 1639 * | | | | | 1640 * |_|_|___________________|_______| 1641 * | | | ---> first line 1642 * | |___________________|---> our kernel console term window 1643 * | 1644 * |---> columns area to be cleared 1645 * 1646 * This function only takes care of the output above our kernel console term, 1647 * and tem_prom_scroll_up takes care of columns area outside of our kernel 1648 * console term. 1649 */ 1650 static void 1651 tem_safe_pix_clear_prom_output(struct tem_vt_state *tem, cred_t *credp, 1652 enum called_from called_from) 1653 { 1654 int nrows, ncols, width, height; 1655 1656 ASSERT((MUTEX_HELD(&tems.ts_lock) && MUTEX_HELD(&tem->tvs_lock)) || 1657 called_from == CALLED_FROM_STANDALONE); 1658 1659 width = tems.ts_font.width; 1660 height = tems.ts_font.height; 1661 1662 nrows = (tems.ts_p_offset.y + (height - 1))/ height; 1663 ncols = (tems.ts_p_dimension.width + (width - 1))/ width; 1664 1665 tem_safe_pix_cls_range(tem, 0, nrows, 0, 0, ncols, 0, 1666 B_FALSE, credp, called_from); 1667 } 1668 1669 /* 1670 * clear the whole screen for pixel mode, just clear the 1671 * physical screen. 1672 */ 1673 void 1674 tem_safe_pix_clear_entire_screen(struct tem_vt_state *tem, cred_t *credp, 1675 enum called_from called_from) 1676 { 1677 int nrows, ncols, width, height; 1678 1679 ASSERT((MUTEX_HELD(&tems.ts_lock) && MUTEX_HELD(&tem->tvs_lock)) || 1680 called_from == CALLED_FROM_STANDALONE); 1681 1682 width = tems.ts_font.width; 1683 height = tems.ts_font.height; 1684 1685 nrows = (tems.ts_p_dimension.height + (height - 1))/ height; 1686 ncols = (tems.ts_p_dimension.width + (width - 1))/ width; 1687 1688 tem_safe_pix_cls_range(tem, 0, nrows, 0, 0, ncols, 0, 1689 B_FALSE, credp, called_from); 1690 1691 /* 1692 * Since the whole screen is cleared, we don't need 1693 * to clear OBP output later. 1694 */ 1695 if (tem->tvs_first_line > 0) 1696 tem->tvs_first_line = 0; 1697 } 1698 1699 /* 1700 * clear the whole screen, including the virtual screen buffer, 1701 * and reset the cursor to start point. 1702 */ 1703 static void 1704 tem_safe_cls(struct tem_vt_state *tem, 1705 cred_t *credp, enum called_from called_from) 1706 { 1707 int row; 1708 1709 ASSERT((MUTEX_HELD(&tems.ts_lock) && MUTEX_HELD(&tem->tvs_lock)) || 1710 called_from == CALLED_FROM_STANDALONE); 1711 1712 if (tems.ts_display_mode == VIS_TEXT) { 1713 for (row = 0; row < tems.ts_c_dimension.height; row++) { 1714 tem_safe_clear_chars(tem, tems.ts_c_dimension.width, 1715 row, 0, credp, called_from); 1716 } 1717 tem->tvs_c_cursor.row = 0; 1718 tem->tvs_c_cursor.col = 0; 1719 tem_safe_align_cursor(tem); 1720 return; 1721 } 1722 1723 ASSERT(tems.ts_display_mode == VIS_PIXEL); 1724 1725 for (row = 0; row < tems.ts_c_dimension.height; row++) { 1726 tem_safe_virtual_cls(tem, tems.ts_c_dimension.width, row, 0); 1727 } 1728 tem->tvs_c_cursor.row = 0; 1729 tem->tvs_c_cursor.col = 0; 1730 tem_safe_align_cursor(tem); 1731 1732 if (!tem->tvs_isactive) 1733 return; 1734 1735 tem_safe_pix_clear_entire_screen(tem, credp, called_from); 1736 } 1737 1738 static void 1739 tem_safe_back_tab(struct tem_vt_state *tem, 1740 cred_t *credp, enum called_from called_from) 1741 { 1742 int i; 1743 screen_pos_t tabstop; 1744 1745 ASSERT((MUTEX_HELD(&tems.ts_lock) && MUTEX_HELD(&tem->tvs_lock)) || 1746 called_from == CALLED_FROM_STANDALONE); 1747 1748 tabstop = 0; 1749 1750 for (i = tem->tvs_ntabs - 1; i >= 0; i--) { 1751 if (tem->tvs_tabs[i] < tem->tvs_c_cursor.col) { 1752 tabstop = tem->tvs_tabs[i]; 1753 break; 1754 } 1755 } 1756 1757 tem_safe_mv_cursor(tem, tem->tvs_c_cursor.row, 1758 tabstop, credp, called_from); 1759 } 1760 1761 static void 1762 tem_safe_tab(struct tem_vt_state *tem, 1763 cred_t *credp, enum called_from called_from) 1764 { 1765 int i; 1766 screen_pos_t tabstop; 1767 1768 ASSERT((MUTEX_HELD(&tems.ts_lock) && MUTEX_HELD(&tem->tvs_lock)) || 1769 called_from == CALLED_FROM_STANDALONE); 1770 1771 tabstop = tems.ts_c_dimension.width - 1; 1772 1773 for (i = 0; i < tem->tvs_ntabs; i++) { 1774 if (tem->tvs_tabs[i] > tem->tvs_c_cursor.col) { 1775 tabstop = tem->tvs_tabs[i]; 1776 break; 1777 } 1778 } 1779 1780 tem_safe_mv_cursor(tem, tem->tvs_c_cursor.row, 1781 tabstop, credp, called_from); 1782 } 1783 1784 static void 1785 tem_safe_set_tab(struct tem_vt_state *tem) 1786 { 1787 int i; 1788 int j; 1789 1790 if (tem->tvs_ntabs == TEM_MAXTAB) 1791 return; 1792 if (tem->tvs_ntabs == 0 || 1793 tem->tvs_tabs[tem->tvs_ntabs] < tem->tvs_c_cursor.col) { 1794 tem->tvs_tabs[tem->tvs_ntabs++] = tem->tvs_c_cursor.col; 1795 return; 1796 } 1797 for (i = 0; i < tem->tvs_ntabs; i++) { 1798 if (tem->tvs_tabs[i] == tem->tvs_c_cursor.col) 1799 return; 1800 if (tem->tvs_tabs[i] > tem->tvs_c_cursor.col) { 1801 for (j = tem->tvs_ntabs - 1; j >= i; j--) 1802 tem->tvs_tabs[j+ 1] = tem->tvs_tabs[j]; 1803 tem->tvs_tabs[i] = tem->tvs_c_cursor.col; 1804 tem->tvs_ntabs++; 1805 return; 1806 } 1807 } 1808 } 1809 1810 static void 1811 tem_safe_clear_tabs(struct tem_vt_state *tem, int action) 1812 { 1813 int i; 1814 int j; 1815 1816 switch (action) { 1817 case 3: /* clear all tabs */ 1818 tem->tvs_ntabs = 0; 1819 break; 1820 case 0: /* clr tab at cursor */ 1821 1822 for (i = 0; i < tem->tvs_ntabs; i++) { 1823 if (tem->tvs_tabs[i] == tem->tvs_c_cursor.col) { 1824 tem->tvs_ntabs--; 1825 for (j = i; j < tem->tvs_ntabs; j++) 1826 tem->tvs_tabs[j] = tem->tvs_tabs[j + 1]; 1827 return; 1828 } 1829 } 1830 break; 1831 } 1832 } 1833 1834 static void 1835 tem_safe_mv_cursor(struct tem_vt_state *tem, int row, int col, 1836 cred_t *credp, enum called_from called_from) 1837 { 1838 ASSERT((MUTEX_HELD(&tems.ts_lock) && MUTEX_HELD(&tem->tvs_lock)) || 1839 called_from == CALLED_FROM_STANDALONE); 1840 1841 /* 1842 * Sanity check and bounds enforcement. Out of bounds requests are 1843 * clipped to the screen boundaries. This seems to be what SPARC 1844 * does. 1845 */ 1846 if (row < 0) 1847 row = 0; 1848 if (row >= tems.ts_c_dimension.height) 1849 row = tems.ts_c_dimension.height - 1; 1850 if (col < 0) 1851 col = 0; 1852 if (col >= tems.ts_c_dimension.width) 1853 col = tems.ts_c_dimension.width - 1; 1854 1855 tem_safe_send_data(tem, credp, called_from); 1856 tem->tvs_c_cursor.row = (screen_pos_t)row; 1857 tem->tvs_c_cursor.col = (screen_pos_t)col; 1858 tem_safe_align_cursor(tem); 1859 } 1860 1861 /* ARGSUSED */ 1862 void 1863 tem_safe_reset_emulator(struct tem_vt_state *tem, 1864 cred_t *credp, enum called_from called_from, 1865 boolean_t init_color) 1866 { 1867 int j; 1868 1869 ASSERT((MUTEX_HELD(&tems.ts_lock) && MUTEX_HELD(&tem->tvs_lock)) || 1870 called_from == CALLED_FROM_STANDALONE); 1871 1872 tem->tvs_c_cursor.row = 0; 1873 tem->tvs_c_cursor.col = 0; 1874 tem->tvs_r_cursor.row = 0; 1875 tem->tvs_r_cursor.col = 0; 1876 tem->tvs_s_cursor.row = 0; 1877 tem->tvs_s_cursor.col = 0; 1878 tem->tvs_outindex = 0; 1879 tem->tvs_state = A_STATE_START; 1880 tem->tvs_gotparam = B_FALSE; 1881 tem->tvs_curparam = 0; 1882 tem->tvs_paramval = 0; 1883 tem->tvs_nscroll = 1; 1884 1885 if (init_color) { 1886 /* use initial settings */ 1887 tem->tvs_fg_color = tems.ts_init_color.fg_color; 1888 tem->tvs_bg_color = tems.ts_init_color.bg_color; 1889 tem->tvs_flags = tems.ts_init_color.a_flags; 1890 } 1891 1892 /* 1893 * set up the initial tab stops 1894 */ 1895 tem->tvs_ntabs = 0; 1896 for (j = 8; j < tems.ts_c_dimension.width; j += 8) 1897 tem->tvs_tabs[tem->tvs_ntabs++] = (screen_pos_t)j; 1898 1899 for (j = 0; j < TEM_MAXPARAMS; j++) 1900 tem->tvs_params[j] = 0; 1901 } 1902 1903 void 1904 tem_safe_reset_display(struct tem_vt_state *tem, 1905 cred_t *credp, enum called_from called_from, 1906 boolean_t clear_txt, boolean_t init_color) 1907 { 1908 ASSERT((MUTEX_HELD(&tems.ts_lock) && MUTEX_HELD(&tem->tvs_lock)) || 1909 called_from == CALLED_FROM_STANDALONE); 1910 1911 tem_safe_reset_emulator(tem, credp, called_from, init_color); 1912 1913 if (clear_txt) { 1914 if (tem->tvs_isactive) 1915 tem_safe_callback_cursor(tem, 1916 VIS_HIDE_CURSOR, credp, called_from); 1917 1918 tem_safe_cls(tem, credp, called_from); 1919 1920 if (tem->tvs_isactive) 1921 tem_safe_callback_cursor(tem, 1922 VIS_DISPLAY_CURSOR, credp, called_from); 1923 } 1924 } 1925 1926 static void 1927 tem_safe_shift( 1928 struct tem_vt_state *tem, 1929 int count, 1930 int direction, 1931 cred_t *credp, 1932 enum called_from called_from) 1933 { 1934 int rest_of_line; 1935 1936 ASSERT((MUTEX_HELD(&tems.ts_lock) && MUTEX_HELD(&tem->tvs_lock)) || 1937 called_from == CALLED_FROM_STANDALONE); 1938 1939 rest_of_line = tems.ts_c_dimension.width - tem->tvs_c_cursor.col; 1940 if (count > rest_of_line) 1941 count = rest_of_line; 1942 1943 if (count <= 0) 1944 return; 1945 1946 switch (direction) { 1947 case TEM_SHIFT_LEFT: 1948 if (count < rest_of_line) { 1949 tem_safe_copy_area(tem, 1950 tem->tvs_c_cursor.col + count, 1951 tem->tvs_c_cursor.row, 1952 tems.ts_c_dimension.width - 1, 1953 tem->tvs_c_cursor.row, 1954 tem->tvs_c_cursor.col, 1955 tem->tvs_c_cursor.row, 1956 credp, called_from); 1957 } 1958 1959 tem_safe_clear_chars(tem, count, tem->tvs_c_cursor.row, 1960 (tems.ts_c_dimension.width - count), credp, 1961 called_from); 1962 break; 1963 case TEM_SHIFT_RIGHT: 1964 if (count < rest_of_line) { 1965 tem_safe_copy_area(tem, 1966 tem->tvs_c_cursor.col, 1967 tem->tvs_c_cursor.row, 1968 tems.ts_c_dimension.width - count - 1, 1969 tem->tvs_c_cursor.row, 1970 tem->tvs_c_cursor.col + count, 1971 tem->tvs_c_cursor.row, 1972 credp, called_from); 1973 } 1974 1975 tem_safe_clear_chars(tem, count, tem->tvs_c_cursor.row, 1976 tem->tvs_c_cursor.col, credp, called_from); 1977 break; 1978 } 1979 } 1980 1981 void 1982 tem_safe_text_cursor(struct tem_vt_state *tem, short action, 1983 cred_t *credp, enum called_from called_from) 1984 { 1985 struct vis_conscursor ca; 1986 1987 ASSERT((MUTEX_HELD(&tems.ts_lock) && MUTEX_HELD(&tem->tvs_lock)) || 1988 called_from == CALLED_FROM_STANDALONE); 1989 1990 ca.row = tem->tvs_c_cursor.row; 1991 ca.col = tem->tvs_c_cursor.col; 1992 ca.action = action; 1993 1994 tems_safe_cursor(&ca, credp, called_from); 1995 1996 if (action == VIS_GET_CURSOR) { 1997 tem->tvs_c_cursor.row = ca.row; 1998 tem->tvs_c_cursor.col = ca.col; 1999 } 2000 } 2001 2002 void 2003 tem_safe_pix_cursor(struct tem_vt_state *tem, short action, 2004 cred_t *credp, enum called_from called_from) 2005 { 2006 struct vis_conscursor ca; 2007 2008 ASSERT((MUTEX_HELD(&tems.ts_lock) && MUTEX_HELD(&tem->tvs_lock)) || 2009 called_from == CALLED_FROM_STANDALONE); 2010 2011 ca.row = tem->tvs_c_cursor.row * tems.ts_font.height + 2012 tems.ts_p_offset.y; 2013 ca.col = tem->tvs_c_cursor.col * tems.ts_font.width + 2014 tems.ts_p_offset.x; 2015 ca.width = tems.ts_font.width; 2016 ca.height = tems.ts_font.height; 2017 if (tems.ts_pdepth == 8 || tems.ts_pdepth == 4) { 2018 if (tem->tvs_flags & TEM_ATTR_REVERSE) { 2019 ca.fg_color.mono = TEM_TEXT_WHITE; 2020 ca.bg_color.mono = TEM_TEXT_BLACK; 2021 } else { 2022 ca.fg_color.mono = TEM_TEXT_BLACK; 2023 ca.bg_color.mono = TEM_TEXT_WHITE; 2024 } 2025 } else if (tems.ts_pdepth == 24 || tems.ts_pdepth == 32) { 2026 if (tem->tvs_flags & TEM_ATTR_REVERSE) { 2027 ca.fg_color.twentyfour[0] = TEM_TEXT_WHITE24_RED; 2028 ca.fg_color.twentyfour[1] = TEM_TEXT_WHITE24_GREEN; 2029 ca.fg_color.twentyfour[2] = TEM_TEXT_WHITE24_BLUE; 2030 2031 ca.bg_color.twentyfour[0] = TEM_TEXT_BLACK24_RED; 2032 ca.bg_color.twentyfour[1] = TEM_TEXT_BLACK24_GREEN; 2033 ca.bg_color.twentyfour[2] = TEM_TEXT_BLACK24_BLUE; 2034 } else { 2035 ca.fg_color.twentyfour[0] = TEM_TEXT_BLACK24_RED; 2036 ca.fg_color.twentyfour[1] = TEM_TEXT_BLACK24_GREEN; 2037 ca.fg_color.twentyfour[2] = TEM_TEXT_BLACK24_BLUE; 2038 2039 ca.bg_color.twentyfour[0] = TEM_TEXT_WHITE24_RED; 2040 ca.bg_color.twentyfour[1] = TEM_TEXT_WHITE24_GREEN; 2041 ca.bg_color.twentyfour[2] = TEM_TEXT_WHITE24_BLUE; 2042 } 2043 } 2044 2045 ca.action = action; 2046 2047 tems_safe_cursor(&ca, credp, called_from); 2048 } 2049 2050 static void 2051 bit_to_pix4(struct tem_vt_state *tem, uchar_t c, text_color_t fg_color, 2052 text_color_t bg_color) 2053 { 2054 uint8_t *dest = (uint8_t *)tem->tvs_pix_data; 2055 font_bit_to_pix4(&tems.ts_font, dest, c, fg_color, bg_color); 2056 } 2057 2058 static void 2059 bit_to_pix8(struct tem_vt_state *tem, uchar_t c, text_color_t fg_color, 2060 text_color_t bg_color) 2061 { 2062 uint8_t *dest = (uint8_t *)tem->tvs_pix_data; 2063 font_bit_to_pix8(&tems.ts_font, dest, c, fg_color, bg_color); 2064 } 2065 2066 static void 2067 bit_to_pix24(struct tem_vt_state *tem, uchar_t c, text_color_t fg_color4, 2068 text_color_t bg_color4) 2069 { 2070 uint32_t fg_color32, bg_color32, *dest; 2071 2072 ASSERT(fg_color4 < 16 && bg_color4 < 16); 2073 2074 fg_color32 = PIX4TO32(fg_color4); 2075 bg_color32 = PIX4TO32(bg_color4); 2076 2077 dest = (uint32_t *)tem->tvs_pix_data; 2078 font_bit_to_pix24(&tems.ts_font, dest, c, fg_color32, bg_color32); 2079 } 2080 2081 static text_color_t 2082 ansi_bg_to_solaris(struct tem_vt_state *tem, int ansi) 2083 { 2084 if (tem->tvs_flags & TEM_ATTR_BRIGHT_BG) 2085 return (brt_xlate[ansi]); 2086 else 2087 return (dim_xlate[ansi]); 2088 } 2089 2090 static text_color_t 2091 ansi_fg_to_solaris(struct tem_vt_state *tem, int ansi) 2092 { 2093 if (tem->tvs_flags & TEM_ATTR_BRIGHT_FG || 2094 tem->tvs_flags & TEM_ATTR_BOLD) { 2095 return (brt_xlate[ansi]); 2096 } else { 2097 return (dim_xlate[ansi]); 2098 } 2099 } 2100 2101 /* 2102 * flag: TEM_ATTR_SCREEN_REVERSE or TEM_ATTR_REVERSE 2103 */ 2104 void 2105 tem_safe_get_color(struct tem_vt_state *tem, text_color_t *fg, 2106 text_color_t *bg, uint8_t flag) 2107 { 2108 if (tem->tvs_flags & flag) { 2109 *fg = ansi_fg_to_solaris(tem, 2110 tem->tvs_bg_color); 2111 *bg = ansi_bg_to_solaris(tem, 2112 tem->tvs_fg_color); 2113 } else { 2114 *fg = ansi_fg_to_solaris(tem, 2115 tem->tvs_fg_color); 2116 *bg = ansi_bg_to_solaris(tem, 2117 tem->tvs_bg_color); 2118 } 2119 } 2120 2121 /* 2122 * Clear a rectangle of screen for pixel mode. 2123 * 2124 * arguments: 2125 * row: start row# 2126 * nrows: the number of rows to clear 2127 * offset_y: the offset of height in pixels to begin clear 2128 * col: start col# 2129 * ncols: the number of cols to clear 2130 * offset_x: the offset of width in pixels to begin clear 2131 * scroll_up: whether this function is called during sroll up, 2132 * which is called only once. 2133 */ 2134 void 2135 tem_safe_pix_cls_range(struct tem_vt_state *tem, 2136 screen_pos_t row, int nrows, int offset_y, 2137 screen_pos_t col, int ncols, int offset_x, 2138 boolean_t sroll_up, cred_t *credp, 2139 enum called_from called_from) 2140 { 2141 struct vis_consdisplay da; 2142 int i, j; 2143 int row_add = 0; 2144 text_color_t fg_color; 2145 text_color_t bg_color; 2146 2147 ASSERT((MUTEX_HELD(&tems.ts_lock) && MUTEX_HELD(&tem->tvs_lock)) || 2148 called_from == CALLED_FROM_STANDALONE); 2149 2150 if (sroll_up) 2151 row_add = tems.ts_c_dimension.height - 1; 2152 2153 da.width = tems.ts_font.width; 2154 da.height = tems.ts_font.height; 2155 2156 tem_safe_get_color(tem, &fg_color, &bg_color, TEM_ATTR_SCREEN_REVERSE); 2157 2158 tem_safe_callback_bit2pix(tem, ' ', fg_color, bg_color); 2159 da.data = (uchar_t *)tem->tvs_pix_data; 2160 2161 for (i = 0; i < nrows; i++, row++) { 2162 da.row = (row + row_add) * da.height + offset_y; 2163 da.col = col * da.width + offset_x; 2164 for (j = 0; j < ncols; j++) { 2165 tems_safe_display(&da, credp, called_from); 2166 da.col += da.width; 2167 } 2168 } 2169 } 2170 2171 /* 2172 * virtual screen operations 2173 */ 2174 static void 2175 tem_safe_virtual_display(struct tem_vt_state *tem, unsigned char *string, 2176 int count, screen_pos_t row, screen_pos_t col, 2177 text_color_t fg_color, text_color_t bg_color) 2178 { 2179 int i, width; 2180 unsigned char *addr; 2181 text_color_t *pfgcolor; 2182 text_color_t *pbgcolor; 2183 2184 if (row < 0 || row >= tems.ts_c_dimension.height || 2185 col < 0 || col >= tems.ts_c_dimension.width || 2186 col + count > tems.ts_c_dimension.width) 2187 return; 2188 2189 width = tems.ts_c_dimension.width; 2190 addr = tem->tvs_screen_buf + (row * width + col); 2191 pfgcolor = tem->tvs_fg_buf + (row * width + col); 2192 pbgcolor = tem->tvs_bg_buf + (row * width + col); 2193 for (i = 0; i < count; i++) { 2194 *addr++ = string[i]; 2195 *pfgcolor++ = fg_color; 2196 *pbgcolor++ = bg_color; 2197 } 2198 } 2199 2200 static void 2201 i_virtual_copy(unsigned char *base, 2202 screen_pos_t s_col, screen_pos_t s_row, 2203 screen_pos_t e_col, screen_pos_t e_row, 2204 screen_pos_t t_col, screen_pos_t t_row) 2205 { 2206 unsigned char *from; 2207 unsigned char *to; 2208 int cnt; 2209 screen_size_t chars_per_row; 2210 unsigned char *to_row_start; 2211 unsigned char *from_row_start; 2212 screen_size_t rows_to_move; 2213 int cols = tems.ts_c_dimension.width; 2214 2215 chars_per_row = e_col - s_col + 1; 2216 rows_to_move = e_row - s_row + 1; 2217 2218 to_row_start = base + ((t_row * cols) + t_col); 2219 from_row_start = base + ((s_row * cols) + s_col); 2220 2221 if (to_row_start < from_row_start) { 2222 while (rows_to_move-- > 0) { 2223 to = to_row_start; 2224 from = from_row_start; 2225 to_row_start += cols; 2226 from_row_start += cols; 2227 for (cnt = chars_per_row; cnt-- > 0; ) 2228 *to++ = *from++; 2229 } 2230 } else { 2231 /* 2232 * Offset to the end of the region and copy backwards. 2233 */ 2234 cnt = rows_to_move * cols + chars_per_row; 2235 to_row_start += cnt; 2236 from_row_start += cnt; 2237 2238 while (rows_to_move-- > 0) { 2239 to_row_start -= cols; 2240 from_row_start -= cols; 2241 to = to_row_start; 2242 from = from_row_start; 2243 for (cnt = chars_per_row; cnt-- > 0; ) 2244 *--to = *--from; 2245 } 2246 } 2247 } 2248 2249 static void 2250 tem_safe_virtual_copy(struct tem_vt_state *tem, 2251 screen_pos_t s_col, screen_pos_t s_row, 2252 screen_pos_t e_col, screen_pos_t e_row, 2253 screen_pos_t t_col, screen_pos_t t_row) 2254 { 2255 screen_size_t chars_per_row; 2256 screen_size_t rows_to_move; 2257 int rows = tems.ts_c_dimension.height; 2258 int cols = tems.ts_c_dimension.width; 2259 2260 if (s_col < 0 || s_col >= cols || 2261 s_row < 0 || s_row >= rows || 2262 e_col < 0 || e_col >= cols || 2263 e_row < 0 || e_row >= rows || 2264 t_col < 0 || t_col >= cols || 2265 t_row < 0 || t_row >= rows || 2266 s_col > e_col || 2267 s_row > e_row) 2268 return; 2269 2270 chars_per_row = e_col - s_col + 1; 2271 rows_to_move = e_row - s_row + 1; 2272 2273 /* More sanity checks. */ 2274 if (t_row + rows_to_move > rows || 2275 t_col + chars_per_row > cols) 2276 return; 2277 2278 i_virtual_copy(tem->tvs_screen_buf, s_col, s_row, 2279 e_col, e_row, t_col, t_row); 2280 2281 /* text_color_t is the same size as char */ 2282 i_virtual_copy((unsigned char *)tem->tvs_fg_buf, 2283 s_col, s_row, e_col, e_row, t_col, t_row); 2284 i_virtual_copy((unsigned char *)tem->tvs_bg_buf, 2285 s_col, s_row, e_col, e_row, t_col, t_row); 2286 2287 } 2288 2289 static void 2290 tem_safe_virtual_cls(struct tem_vt_state *tem, 2291 int count, screen_pos_t row, screen_pos_t col) 2292 { 2293 text_color_t fg_color; 2294 text_color_t bg_color; 2295 2296 tem_safe_get_color(tem, &fg_color, &bg_color, TEM_ATTR_SCREEN_REVERSE); 2297 tem_safe_virtual_display(tem, tems.ts_blank_line, count, row, col, 2298 fg_color, bg_color); 2299 } 2300 2301 /* 2302 * only blank screen, not clear our screen buffer 2303 */ 2304 void 2305 tem_safe_blank_screen(struct tem_vt_state *tem, cred_t *credp, 2306 enum called_from called_from) 2307 { 2308 int row; 2309 2310 ASSERT((MUTEX_HELD(&tems.ts_lock) && MUTEX_HELD(&tem->tvs_lock)) || 2311 called_from == CALLED_FROM_STANDALONE); 2312 2313 if (tems.ts_display_mode == VIS_PIXEL) { 2314 tem_safe_pix_clear_entire_screen(tem, credp, called_from); 2315 return; 2316 } 2317 2318 for (row = 0; row < tems.ts_c_dimension.height; row++) { 2319 tem_safe_callback_cls(tem, 2320 tems.ts_c_dimension.width, 2321 row, 0, credp, called_from); 2322 } 2323 } 2324 2325 /* 2326 * unblank screen with associated tem from its screen buffer 2327 */ 2328 void 2329 tem_safe_unblank_screen(struct tem_vt_state *tem, cred_t *credp, 2330 enum called_from called_from) 2331 { 2332 text_color_t fg_color, fg_last; 2333 text_color_t bg_color, bg_last; 2334 size_t tc_size = sizeof (text_color_t); 2335 int row, col, count, col_start; 2336 int width; 2337 unsigned char *buf; 2338 2339 ASSERT((MUTEX_HELD(&tems.ts_lock) && MUTEX_HELD(&tem->tvs_lock)) || 2340 called_from == CALLED_FROM_STANDALONE); 2341 2342 if (tems.ts_display_mode == VIS_PIXEL) 2343 tem_safe_pix_clear_entire_screen(tem, credp, called_from); 2344 2345 tem_safe_callback_cursor(tem, VIS_HIDE_CURSOR, credp, called_from); 2346 2347 width = tems.ts_c_dimension.width; 2348 2349 /* 2350 * Display data in tvs_screen_buf to the actual framebuffer in a 2351 * row by row way. 2352 * When dealing with one row, output data with the same foreground 2353 * and background color all together. 2354 */ 2355 for (row = 0; row < tems.ts_c_dimension.height; row++) { 2356 buf = tem->tvs_screen_buf + (row * width); 2357 count = col_start = 0; 2358 for (col = 0; col < width; col++) { 2359 fg_color = 2360 tem->tvs_fg_buf[(row * width + col) * tc_size]; 2361 bg_color = 2362 tem->tvs_bg_buf[(row * width + col) * tc_size]; 2363 if (col == 0) { 2364 fg_last = fg_color; 2365 bg_last = bg_color; 2366 } 2367 2368 if ((fg_color != fg_last) || (bg_color != bg_last)) { 2369 /* 2370 * Call the primitive to render this data. 2371 */ 2372 tem_safe_callback_display(tem, 2373 buf, count, row, col_start, 2374 fg_last, bg_last, credp, called_from); 2375 buf += count; 2376 count = 1; 2377 col_start = col; 2378 fg_last = fg_color; 2379 bg_last = bg_color; 2380 } else { 2381 count++; 2382 } 2383 } 2384 2385 if (col_start == (width - 1)) 2386 continue; 2387 2388 /* 2389 * Call the primitive to render this data. 2390 */ 2391 tem_safe_callback_display(tem, 2392 buf, count, row, col_start, 2393 fg_last, bg_last, credp, called_from); 2394 } 2395 2396 tem_safe_callback_cursor(tem, VIS_DISPLAY_CURSOR, credp, called_from); 2397 } 2398