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